{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb) | [Contents](Index.ipynb) | [In-Depth: Support Vector Machines](05.07-Support-Vector-Machines.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.06-Linear-Regression.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# In Depth: Linear Regression\n",
    "\n",
    "# 深入：线性回归"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Just as naive Bayes (discussed earlier in [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb)) is a good starting point for classification tasks, linear regression models are a good starting point for regression tasks.\n",
    "Such models are popular because they can be fit very quickly, and are very interpretable.\n",
    "You are probably familiar with the simplest form of a linear regression model (i.e., fitting a straight line to data) but such models can be extended to model more complicated data behavior.\n",
    "\n",
    "就像朴素贝叶斯（前面在[深入：朴素贝叶斯分类](05.05-Naive-Bayes.ipynb)中讨论过）是分类任务的好入门点一样，线性回归模型是回归任务的好入门点。这样的模型因为它们能够快速的训练拟合以及非常容易解释而流行。也许你已经熟悉线性回归模型的简单形式（例如让一条直线拟合到数据上），但是这样的模型也能够扩展到更加复杂的数据上。\n",
    "\n",
    "> In this section we will start with a quick intuitive walk-through of the mathematics behind this well-known problem, before seeing how before moving on to see how linear models can be generalized to account for more complicated patterns in data.\n",
    "\n",
    "> We begin with the standard imports:\n",
    "\n",
    "本节中我们首先快速直观的介绍这个著名问题背后的数学基础，然后再讨论这些线性模型如何能够泛化到适应更复杂的数据模式上。\n",
    "\n",
    "我们先载入需要的包："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%matplotlib inline\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns; sns.set()\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Simple Linear Regression\n",
    "\n",
    "## 简单线性回归\n",
    "\n",
    "> We will start with the most familiar linear regression, a straight-line fit to data.\n",
    "A straight-line fit is a model of the form\n",
    "$$\n",
    "y = ax + b\n",
    "$$\n",
    "where $a$ is commonly known as the *slope*, and $b$ is commonly known as the *intercept*.\n",
    "\n",
    "我们先从最熟悉的线性回归模型开始，用一条直线拟合数据。一条拟合直线的模型具有下面的数学形式\n",
    "$$\n",
    "y = ax + b\n",
    "$$\n",
    "其中的$a$通常被称为*斜率*，而$b$通常被成为*截距*。\n",
    "\n",
    "> Consider the following data, which is scattered about a line with a slope of 2 and an intercept of -5:\n",
    "\n",
    "下面的数据是一些随机散落在一条斜率为2截距为-5的直线附近的点："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rng = np.random.RandomState(1)\n",
    "x = 10 * rng.rand(50)\n",
    "y = 2 * x - 5 + rng.randn(50)\n",
    "plt.scatter(x, y);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We can use Scikit-Learn's ``LinearRegression`` estimator to fit this data and construct the best-fit line:\n",
    "\n",
    "我们可以使用Scikit-Learn的`LinearRegression`评估器来拟合这些数据然后得到一条最佳拟合直线："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "model = LinearRegression(fit_intercept=True)\n",
    "\n",
    "model.fit(x[:, np.newaxis], y)\n",
    "\n",
    "xfit = np.linspace(0, 10, 1000)\n",
    "yfit = model.predict(xfit[:, np.newaxis])\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(xfit, yfit);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The slope and intercept of the data are contained in the model's fit parameters, which in Scikit-Learn are always marked by a trailing underscore.\n",
    "Here the relevant parameters are ``coef_`` and ``intercept_``:\n",
    "\n",
    "数据的斜率和截距可以在模型拟合参数中找到，在Scikit-Learn中总是使用下划线后缀来表示。这里相关的参数是`coef_`和`intercept_`："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model slope:     2.027208810360695\n",
      "Model intercept: -4.998577085553202\n"
     ]
    }
   ],
   "source": [
    "print(\"Model slope:    \", model.coef_[0])\n",
    "print(\"Model intercept:\", model.intercept_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We see that the results are very close to the inputs, as we might hope.\n",
    "\n",
    "可以看到结果非常接近输入，正如我们所料。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The ``LinearRegression`` estimator is much more capable than this, however—in addition to simple straight-line fits, it can also handle multidimensional linear models of the form\n",
    "$$\n",
    "y = a_0 + a_1 x_1 + a_2 x_2 + \\cdots\n",
    "$$\n",
    "where there are multiple $x$ values.\n",
    "Geometrically, this is akin to fitting a plane to points in three dimensions, or fitting a hyper-plane to points in higher dimensions.\n",
    "\n",
    "`LinearRegression`评估器能做的远不止于此，除了简单的直线拟合外，它还能处理多维线性模型的形式\n",
    "$$\n",
    "y = a_0 + a_1 x_1 + a_2 x_2 + \\cdots\n",
    "$$\n",
    "这里有多个$x$值。几何上，这等同于在三维空间间使用一个平面拟合数据，或在更高维空间中使用超平面拟合数据。\n",
    "\n",
    "> The multidimensional nature of such regressions makes them more difficult to visualize, but we can see one of these fits in action by building some example data, using NumPy's matrix multiplication operator:\n",
    "\n",
    "这样的回归具有多维的本质，因此令它们比较难以可视化，但我们可以构造一些样例数据来查看这样的拟合，这里使用了NumPy的矩阵乘法操作："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5000000000000144\n",
      "[ 1.5 -2.   1. ]\n"
     ]
    }
   ],
   "source": [
    "rng = np.random.RandomState(1)\n",
    "X = 10 * rng.rand(100, 3)\n",
    "y = 0.5 + np.dot(X, [1.5, -2., 1.])\n",
    "\n",
    "model.fit(X, y)\n",
    "print(model.intercept_)\n",
    "print(model.coef_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Here the $y$ data is constructed from three random $x$ values, and the linear regression recovers the coefficients used to construct the data.\n",
    "\n",
    "这里$y$值是由三个随机$x$值构建的，而线性回归恢复了用来构建数据的斜率。\n",
    "\n",
    "> In this way, we can use the single ``LinearRegression`` estimator to fit lines, planes, or hyperplanes to our data.\n",
    "It still appears that this approach would be limited to strictly linear relationships between variables, but it turns out we can relax this as well.\n",
    "\n",
    "使用这种方法，我们可以使用单个`LinearRegression`评估器拟合直线、平面或超平面到数据上。目前为止这种方法看起来都限制在变量之间的线性关联上，但是实际上它还能完成更多的工作。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Basis Function Regression\n",
    "\n",
    "## 基本函数回归\n",
    "\n",
    "> One trick you can use to adapt linear regression to nonlinear relationships between variables is to transform the data according to *basis functions*.\n",
    "We have seen one version of this before, in the ``PolynomialRegression`` pipeline used in [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) and [Feature Engineering](05.04-Feature-Engineering.ipynb).\n",
    "The idea is to take our multidimensional linear model:\n",
    "$$\n",
    "y = a_0 + a_1 x_1 + a_2 x_2 + a_3 x_3 + \\cdots\n",
    "$$\n",
    "and build the $x_1, x_2, x_3,$ and so on, from our single-dimensional input $x$.\n",
    "That is, we let $x_n = f_n(x)$, where $f_n()$ is some function that transforms our data.\n",
    "\n",
    "将线性回归应用在变量之间的非线性关系的一个技巧是，将数据通过*基本函数*进行转换。我们在[超参数和模型验证](05.03-Hyperparameters-and-Model-Validation.ipynb)和[特征工程](05.04-Feature-Engineering.ipynb)中已经看到过多项式回归`PolynomialRegression`管道操作中已经看到这个技巧的例子。这个方法是将一维的输入数据使用多维线性模型\n",
    "$$\n",
    "y = a_0 + a_1 x_1 + a_2 x_2 + a_3 x_3 + \\cdots\n",
    "$$\n",
    "来建立$x_1, x_2, x_3$等。即我们令$x_n = f_n(x)$其中的$f_n()$是用来转换数据的函数。\n",
    "\n",
    "> For example, if $f_n(x) = x^n$, our model becomes a polynomial regression:\n",
    "$$\n",
    "y = a_0 + a_1 x + a_2 x^2 + a_3 x^3 + \\cdots\n",
    "$$\n",
    "Notice that this is *still a linear model*—the linearity refers to the fact that the coefficients $a_n$ never multiply or divide each other.\n",
    "What we have effectively done is taken our one-dimensional $x$ values and projected them into a higher dimension, so that a linear fit can fit more complicated relationships between $x$ and $y$.\n",
    "\n",
    "例如，如果令$f_n(x) = x^n$，我们的模型就会变成一个多项式回归：\n",
    "$$\n",
    "y = a_0 + a_1 x + a_2 x^2 + a_3 x^3 + \\cdots\n",
    "$$\n",
    "注意这里模型仍然是*线性的*，线性的意思是指模型中的斜率$a_n$没有互相进行乘法或除法操作。这里起作用的是我们将一维的$x$值投射到了更高的维度上，这样我们的线性模型就能拟合$x$和$y$之间更加复杂的联系。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Polynomial basis functions\n",
    "\n",
    "### 多项式基本函数\n",
    "\n",
    "> This polynomial projection is useful enough that it is built into Scikit-Learn, using the ``PolynomialFeatures`` transformer:\n",
    "\n",
    "这种多项式投射如此有用所以Scikit-Learn內建了实现它的方法，就是`PolynomialFeatures`转换："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2.,  4.,  8.],\n",
       "       [ 3.,  9., 27.],\n",
       "       [ 4., 16., 64.]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.preprocessing import PolynomialFeatures\n",
    "x = np.array([2, 3, 4])\n",
    "poly = PolynomialFeatures(3, include_bias=False)\n",
    "poly.fit_transform(x[:, None])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We see here that the transformer has converted our one-dimensional array into a three-dimensional array by taking the exponent of each value.\n",
    "This new, higher-dimensional data representation can then be plugged into a linear regression.\n",
    "\n",
    "我们看到上例中使用这个转换器我们对每个值求幂将一维数组变成了三维数组。这个新的高维数据表示能应用到线性回归中。\n",
    "\n",
    "> As we saw in [Feature Engineering](05.04-Feature-Engineering.ipynb), the cleanest way to accomplish this is to use a pipeline.\n",
    "Let's make a 7th-degree polynomial model in this way:\n",
    "\n",
    "正如我们在[特征工程](05.04-Feature-Engineering.ipynb)中看到的，实现这个任务的最优雅犯法是使用管道。这里我们创建一个7阶的多项式模型："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.pipeline import make_pipeline\n",
    "poly_model = make_pipeline(PolynomialFeatures(7),\n",
    "                           LinearRegression())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With this transform in place, we can use the linear model to fit much more complicated relationships between $x$ and $y$. \n",
    "For example, here is a sine wave with noise:\n",
    "\n",
    "有了这样的转换方式，我们可以使用线性模型来拟合复杂得多的$x$和$y$的关系。例如像下面的带有噪音的正弦波："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "rng = np.random.RandomState(1)\n",
    "x = 10 * rng.rand(50)\n",
    "y = np.sin(x) + 0.1 * rng.randn(50)\n",
    "\n",
    "poly_model.fit(x[:, np.newaxis], y)\n",
    "yfit = poly_model.predict(xfit[:, np.newaxis])\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(xfit, yfit);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Our linear model, through the use of 7th-order polynomial basis functions, can provide an excellent fit to this non-linear data!\n",
    "\n",
    "这个例子中，我们通过使用7阶多项式函数，使得我们的线性模型能够优异的拟合到这个非线性数据上。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Gaussian basis functions\n",
    "\n",
    "### 高斯基本函数\n",
    "\n",
    "> Of course, other basis functions are possible.\n",
    "For example, one useful pattern is to fit a model that is not a sum of polynomial bases, but a sum of Gaussian bases.\n",
    "The result might look something like the following figure:\n",
    "\n",
    "当然还有其他可用的基本函数。例如可以通过高斯函数叠加而不是多项式叠加来拟合模型。结果可能如下图所示："
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![](figures/05.06-gaussian-basis.png)\n",
    "[附录中生成图像的代码](#Gaussian-Basis)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The shaded regions in the plot are the scaled basis functions, and when added together they reproduce the smooth curve through the data.\n",
    "These Gaussian basis functions are not built into Scikit-Learn, but we can write a custom transformer that will create them, as shown here and illustrated in the following figure (Scikit-Learn transformers are implemented as Python classes; reading Scikit-Learn's source is a good way to see how they can be created):\n",
    "\n",
    "上图中阴影部分是基本函数的范围，当这些阴影叠加在一起时就会产生上面光滑的拟合曲线。Scikit-Learn中没有內建这些高斯基本函数，但我们可以写一个自定义的转换器来构造它们，就像下面代码和图表展示那样（Scikit-Learn的转换器是使用Python类实现的；阅读Scikit-Learn的源代码是理解它们创建的好方法）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.base import BaseEstimator, TransformerMixin\n",
    "\n",
    "class GaussianFeatures(BaseEstimator, TransformerMixin):\n",
    "    \"\"\"对一维数据进行均匀分布高斯转换\"\"\"\n",
    "    \n",
    "    def __init__(self, N, width_factor=2.0):\n",
    "        self.N = N\n",
    "        self.width_factor = width_factor\n",
    "    \n",
    "    @staticmethod\n",
    "    def _gauss_basis(x, y, width, axis=None):\n",
    "        arg = (x - y) / width\n",
    "        return np.exp(-0.5 * np.sum(arg ** 2, axis))\n",
    "        \n",
    "    def fit(self, X, y=None):\n",
    "        # 沿着数据范围创建均匀分布的N个中心点\n",
    "        self.centers_ = np.linspace(X.min(), X.max(), self.N)\n",
    "        self.width_ = self.width_factor * (self.centers_[1] - self.centers_[0])\n",
    "        return self\n",
    "        \n",
    "    def transform(self, X):\n",
    "        return self._gauss_basis(X[:, :, np.newaxis], self.centers_,\n",
    "                                 self.width_, axis=1)\n",
    "    \n",
    "gauss_model = make_pipeline(GaussianFeatures(20),\n",
    "                            LinearRegression())\n",
    "gauss_model.fit(x[:, np.newaxis], y)\n",
    "yfit = gauss_model.predict(xfit[:, np.newaxis])\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(xfit, yfit)\n",
    "plt.xlim(0, 10);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We put this example here just to make clear that there is nothing magic about polynomial basis functions: if you have some sort of intuition into the generating process of your data that makes you think one basis or another might be appropriate, you can use them as well.\n",
    "\n",
    "我们举这个例子只是为了表示多项式函数并不特殊：如果你对数据的生成过程有了什么灵感，你也可以使用它对应的函数来尝试。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Regularization\n",
    "\n",
    "## 正则化\n",
    "\n",
    "> The introduction of basis functions into our linear regression makes the model much more flexible, but it also can very quickly lead to over-fitting (refer back to [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) for a discussion of this).\n",
    "For example, if we choose too many Gaussian basis functions, we end up with results that don't look so good:\n",
    "\n",
    "将基本函数引入线性回归令我们的模型更加灵活，但是它很容易导致过拟合（参见[超参数和模型验证](05.03-Hyperparameters-and-Model-Validation.ipynb)中的讨论）。例如如果我们选择了太多的高斯函数，产生的结果就不太可靠了："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYgAAAD/CAYAAADrE0HrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXRU153o+2/NKkmlWSAmgRBoAzIYgyeCHTzEdtuZHKedxJ3BuXkvnanTK51Obt9+93WSle6+191Ov3tfBj9n6CS4u+MMHWInjp14xjYWtjHGgIDNIJAQSCA0lqRSze+PqhIlqSSVSjWd0u+zFgvp6FSdraNT53f29NumcDiMEEIIMZk51wUQQgiRnyRACCGESEgChBBCiIQkQAghhEhIAoQQQoiEJEAIIYRIyJquN1JKfQv4ILAK2Ki1Ppxgn28AnwfORzft0Vp/IV1lEEIIkT5pCxDAY8D/C7w8y36PaK2/ksbjCiGEyIC0BQit9SsASql0vaUQQogcSmcNIlkfUUrdDnQDX9datyT5OgdwDdAFBDNVOCGEKDAWYAnwBuCdywuzHSAeBv5Ra+1XSt0GPK6UWq+17k3itdcwe/OVEEKIxG4EXpnLC7IaILTW3XFfP6OUOgtcAexO4uVdAP39I4RCkj+qurqU3t7hXBcjL8i5uEzOxWVyLiLMZhOVlSUQvYfORVYDhFJqmdb6XPTrzURGPOkkXx4ECIXCEiCi5DxcJufiMjkXl8m5mGDOTfPpHOb6beAeoA54VinVq7VuVko9CXxNa70P+B9Kqa3RgvqAj8fXKoQQQuQPk4HSfa8CTvf2DstTAVBb66Knx53rYuQFOReXybm4TM5FhNlsorq6FKABODOn12aiQEIIIYxPAoQQQoiEJEAIIYRISAKEEEKIhCRACCGESEgChBBCiIQkQAghhEhIAoQQQoiEJEAIIYRISAKEEEKIhCRACCGESEgChBBCiIQkQAghhEhIAoQQQoiEJEAIIYRISAKEEEKIhCRACCGESEgChBBCiIQkQAghhEjImusCiJm1tHaza/cpeoe8VJc5uGdHI9ua63JdLCHEAiA1iDzW0trNzqeO0TvkBaB3yMvOp47R0tqd45IJIRYCCRB5bNfuU/gCoQnbfIEQu3afylGJhBALiQSIPBarOSS7XQgh0kkCRB6rLnPMabsQQqSTBIg8ds+ORuzWiX8iu9XMPTsac1QiIcRCIqOY8lhstJKMYhJC5IIEiDy3rblOAoIQIifSFiCUUt8CPgisAjZqrQ8n2McCfBv4EyAMPKC1/lG6ypCPZB6DEMmTz0t+SWcfxGPAO4H2Gfb5KLAGWAtsA76hlFqVxjLklfnOY7g44OHZfWd5YX8n/W4ZuSQKm8z7yT9pq0ForV8BUErNtNuHgR9qrUNAj1LqMeBe4MF0lSOfzDSPYaanIn8gyK9ePMVz+zoJR7f94vmTfPKudVy/QZ6mRGFK9fMiMifbfRD1TKxhdAArslyGrEllHoPXF+Tbvz7I0fZ+bt6yjDuvrccfDLHzD5of/u4IpU4bVzRUZ6rIQuSMzPvJP4brpK6uLs11EZJWW+mkp9+TcHttrWvKdo83wL/8aC+6o5+/um8Lt1x9OXb+Y0MNf/3tl9j5B833vnpL5H0SvMdCJefiMqOei7l+XpJ6T4Oei3yR7QDRAawE3oh+P7lGMave3mFCofDsO+bAwLCXrt5RTnQO8NKBc/S5fVP2sVvN3H1DAz097gnbff4g//tXb3P87CCfef8VbFxZMWWf++9Q/MPOffz0d4f5woeumvLzhaq21iXnIsrI5+KmzUv5ze42AnGf7+k+L8kw8rlIJ7PZlPKDdbYDxK+ATyuldgHVwN1EOrYNrWfAw8+eOc7bp3pn3G+6URn+QIjv/eYwumOAT793A9esW5Tw9Q1Lyrhuw2Ke39/Jx+7akLbyC5Frj79ymsdfOQ2AyQTh8PSfF5E9aRvFpJT6tlKqE1gOPKuUao1uf1IpdXV0t38D2oATwF7gm1rrtnSVIReOnx3gGz95neOdA7xv+yrKim0J96t02Xnw89unXOyjYwG+/Z9vc6itl+IiKz/43RG++tCeaUduvHf7Kvz+EE9EP0xCGN3eI908/spptjXX8aV7N1Fb4aTUaeNvP7ZVgkOOpXMU018Cf5lg+11xXweBz6XrmLnWdn6I//Wrt6ksdfBXH7qS2gonv91zJuG+/W4fT7/ewc1blmGzWgiHw7Se6eM/nj7OxQEPFrOJkbEAcHl4HzDlA7KkuoTm1VU8/Vo7t161BItZsqUI4/L6g/z8uZM0Li3jU+9eh8VsprbCyTd/uo+fPHmUL394MyaTKdfFXLAM10mdLzzeAA8/fhiX08ZX77uKSlckgV51mSPhqAubxcTPnz/JrpfbqKssZnDUx+Cwj5ryIlxOG0Oj/gn7zzS87+bNy/jOrkN8+Tuv4PYEpCouDGv3W+cYGvHx+buvwGI2j0+U8/qDtJ7p5xfPn+Qjt66d1zGCoRAX+jy4im24iu1pKvnCIAEiSZNneNZUOOkdGuNvP7p1PDhAJMHezqeOTRjPbbea2b6xjjd1D0Ojfrr6RllZ5+JPdzRyzbpFfPZfdic8ZqJA09Lazc+e0QC4PbPXOETmDAx7cRXbpBaXolA4zDP7zrKuvoKmFRXjE+XiPzvPvHGW+sWlvOOKJUm/b+yz2jfkpbTYRjgMwx4/JuDGK5fwZ+9qwm6zZOA3KjxyZSch0QxP3THApsZq1iwvn7DvtuY67r9z3XhK7uoyB9s31rHnUPd4LcEfCNHR7cZsNmG3WZJO6x0rx8hYcMq+spBQdu0+cI4vf3cP//SztwiGQrO/QEyh2/vpHfKyY/MyIPFEuTDwi+dOJP2e8Z/VMOAe9TPi8fPOK5dy69XLeentLh5+vDVvR0LmGwkQSUh04QKcvZB4CN225joe/Px2fvzfbuHBz2/n4KneGVeGSzat93TliJEJRdnhDwR57OXTmE0mTnYO8tbxS7kukiG9cqgbp8PKVWtrgOmvX7cnQDic3A19uiDTerqXP3tXEx+9rYkDJy/x+5Yz8yj5wiEBIgnTXbiJ5jnM5fWx7YlqHfffuW5Kc9FsAUAWEsqOw6f7GBzx8cUPbsRVbGOfvpjrIhnOmC/Am8cvcs26RePNPTNdv8fa+5N639k+a7dsWca16xfxu1fP0N03OsdSLzwSIGbR0tqNeZpBFGYTSSUSS6YJaXKtI1FfwkwfIFlIKHuOnOnHbjOzYVUVV62t4eCpXmmymKPDbX34/CGu27B4fFuimrTNYqLYYeWJluTm0872WTOZTNx361psVjO/fP5kiqVfOCRAzCDWnjndZz8UJqlsk+laGS7R+wA4bOaENQ6RGUfb+2laXoHNakatqGTMF+T8pZFcF8tQ3j55iWKHlbVxfXiJatKfvGs973nHKo6293Oyc3DW973z+pVTtk3+rJWXOrjj2noOnLzEme6hNPw2hUtGMc1gtjZ/SC7bZLpWhot/n74hL5UuO0OjfrZvXCLBIUvGfAG6Lo1wbXS2e8PSMgDauoZYvsg4ecJyKRQKc7Ctl42N1VgtEx94Ei2Q5fUFeXJvO7999TRf/tDmhO8ZP8oQwGk3M+YLUTXNZ+22q1fwzBtneezl03zp3ivT+NsVFgkQ02hp7U660zeZ/dK1MlzsfWJ5Zr79nwc5eKqXcDgsE4qyoLNnhDCwIhoMFlU6KXZYOd01xDuvXJrbwhlEW9cQ7lE/V65JLiuxw27hjmtX8OvdbZzuGqJhSdmEnycaHhsMwZf/bAvN9RUJ39PpsHLHtfXseqmN9m43K+skqV8i0sSUQOyCS1YuO4evXFPNpcExaeLIktjItRWLIwHCbDKxvLZkQZ7/ltZuvvrQHj71wPMzpoeZ7O2TlzCbTGxcnXza+lu2LKfUaeMXz52YMqJpunUkHnnq6Kzv6XRYZETTDCRAJJBM01JMrjuHNzVGhgjOlihQpEfnpRGcDgvVZUXj2+qqS+jqXVgjYl45eJ6fPnk0pdXfDpy8RNOKckqKEuctS8TpsPLBHas53jnIK4e6Jvxsuhr8pQSpw+MVF1m5Zcty3tQ9CzLAJ0MCRAIzNRndfNXSWYejZlOly8GKRaUcbpMAkQ0X+z0sriye0Jy3tLqYYY8f92hyw56NrmfAw0+fOoY/OPFJPpnJmpcGPJzrGeHKNTVzPu6Nm5aiVlTwH08fp7378hwkpyPxrOiaSues73nbNSswm038/c435lwTWgikDyLK6wty7tII7d1DWC0mAsGpQ5eqyxx8/I51OSjdzDauruaPr3fg8QZwOuRPmkkX+0entIEvqSkBoKt3dEHk+vn17lPTjuybrT/uwMnIpMLNKQQIs9nEZ9/fzDd37uOffrafmzYv40L/KB5vELOJCWWyW8184s71s75n6+k+wuEwXn94vPzJpq2ZnH6nEPOhLei7yaVBD8+92Unr6T7ORTsfAcpL7Ax7/AQnLVySr/MMNq6u4sm97Rw5089WVZvr4hSsQDBE76CX6zZMfDJdHH1SvdjvoWlF4k7RQjE47OVN3UOR3cKYb2rKl9jcoMk3yvibqdlsoq1riMVVxXM+fnmpg//+8a088kfN02+cpchu4QM3NlBVXsRjL7VNuFnftHXFrAsG7UoQ7JIZmTi5Y7xQ86Et2ADx6uEuHvmDJhgKs66+gi1NtdQvdrF8USm15UXsPXLBME8HjcvKcTosHGrrlQCRQb1DY4TCYRZVTLyxVZUVYYr+vNAdausjGAqzpaGKN3TPlJ/H5gbB5Rvl5JtpKBSe1820qqyIL917JYFgCIvZNN7ct30OCf1iUl0He7qO8dkCi9EsyADx2pEL/OiJo6yrr+D/ePcGqsuLpuyTrmGp2WC1mNmwsopDbTLcNZMuRjs9F01q27ZazJSX2rk0OHOnaCE40t6Hq9jGqfPTT1qbfKPM1M108hyKVEyXnn+2kYmpBhajWXCd1BcHPPz4yaM0LS/nrz60OWFwMKKNjdX0u72ck9EYGRMLEIsTdH7WlDvpHSz8GoTuGGBdfeWsecjib5T5fDOdLr3HbM3JM6XfKSQLLkD87JnjmM0mPvP+K7AlSFthVFc0VAFwSEYzZUzPgAe7zUxZydSO6OryIi4VeIAY9vjpd3tZtcQ16xN2/M+TTWefC5PTewBsbKyZtWYzU/qdQlI4d8gknOwc5OCpXt6/vWHCIj+FoKqsiOW1JRyS+RAZ0zc0RpWrKGETXk15Ef1ub0En7RufJLiodNq8YDGbGi9PgrtnRyPWSY/W+TToIz5R5uY1NRxt76ffnVrm5HwIeum0oALEU6+1U1Jk5earluW6KBmxcXU1JzoH8XgDuS5KQeof9k77YFFdVkQwFGZgOPfNJply9uIwACsWucafvKdrUjkY96CyrbmOxrikfPkwf2g6H751DcFQiB///si0C0EFQyE2NdZM+d3zKeily4IJEL2DYxw4cYmbtyzDYS/M5QY3rq4mGApzNMnc+WJu+t0zBIhoX1ahNjO1tHbzm5fbAPiHnW+MD2VNZj6EPxCi8+Iw25oXz5jOPh8srizmvlvX0nqmn51PaQLBy0HCHwjx0tvn+b9+sJcX3jpHkcOKJS5K7LhqWd7+XqlaMKOYWlq7CQM3bCrchGprlpdTZI8Md93SJMNd0ykUDjM47Js2QFRFU2/0FeBQ15nG/CczCuiNYxcYGQuw7Qpj3Dx3bF5Gv9vLb/ecoa1riC1NNYyOBXhT9zA44mNVnYv7PtjElWuqMZlM9Lu9fHfXQV586xzXrl9E49Ly2Q9iEAuiBhEOh3n1cDdNy8tZVDH79Hujsloii9jEhruK9HGP+AiGwtMGiMrSSMf1wHDhpduYaZhqor4Ii/nyKKBwOMzTb5xlaU0Jzauqslbm+br7xtX8xT0bsVnNPPFqO68c6mJVnYu//vBm/u7+q9m8tma8L6rS5eBL915JeYmdH/72CD7/1AmERrUgahDnL43Q3TfKbdeoXBcl4zaurmL/8UjysWW1sj5BuvRFOy0rSxMHCKfDit1qZnCk8PogZhqmOnmtE5vFhNlsojk6qm7/8R46LgzzyTvXGW5+zpamWrY01RKKPmyZZyi/q9jOf7lzHQ/+/ABP7m3n7htXZ6uYGbUgAkQs02kq+V+MJpZC+VBbnwSINBqIBoiKaWoQJpOJ8lJ7QdYgZmtGip9Ueq5nmG/85A0efuwwt12zgkf+qFleW8r2jcZoXkpkpsAQb/2qKq5et4in9nbw8tvn6R/25X0WhtksiCamt09eon5xacENbU2kqqyIZbUlMh8izWI1iKoZrqGKUsd4ICkkcxmmuqy2lE/dtZ4TnYN859eHMJtMfOEDV2AxL4hbDSvrSvEHQ/RHHxTmkgY9HxV8DWLY4+fkuUHes21VrouSNRtXV/PMG2clu2saDQx7sZhNuBJMkoupKHXQER0KWki2NdehO/p56e3IOgyzPRVvu6KO1cvKONczwvqVlQV7DSbK5vri/nNT9jNyjqbC/MvFOXy6l3AYNiW5vGEh2Lymhj+81sHbJy9xvQEvynzUN+SlvNQ+Y3NDeamdgbbCq0HA5VFa3//KTUllIFhcWcziyrlnazWK6UZ2TbfQWD6kFUlF2gKEUqoJ2AlUA73AJ7TWJybt8w3g88D56KY9WusvpKsMiRxrH8DpsNJQVzb7zgVizfJyKl0OXjtyQQJEmgzMMEkuprLUgdcXLMia28Cwj1KnraDS08zHdCO7Jq9LEWPUGdbp/Gs/DHxPa90EfA/4/jT7PaK13hz9l9HgAKDPDtC0vBxzoWXRmoHZZOK6DYs5fLqPYY8/18UpCH1u77QjmGLKo0NdB0cKr6N6wO2lYpbffyGZrkYQCjNl2K+RZ1inJUAopRYBW4BHo5seBbYoldvFCQaGvVzoG0XVV+ayGDlx3frFBENh3jh2MddFKQhDI17KZ7lBxm6ghdhRPdMs8oVoplxM99+5bnxejNNuydu0IslIVz14BXBOax0E0FoHlVLno9snryryEaXU7UA38HWtdctcDlRdndzQzRffPMsPHj8EwNP7zrJiSRk3bV0xl0Plvdpa17Q/q6kppWFpGS8f7OLe25ThxqDP1UznYr78gSAeb5AltaUzHqchukxtyGzOaHlmk4ljD476UKuqcvp7pSJT5f3ke5r57q/exhs3Kc5hs/DJ9zRz09YVvO+mtXzt+69y7tII792xxrCfv2w3lD4M/KPW2q+Uug14XCm1Xmud9JjM3t7hWTNmTu5AGnB7+c4vDzDkHjNsJJ+sttY163KKO65cyk+fOsae/WcLuhaVzLmYj1j6DHM4PONxAt5Ic965C0MZLc9MMnEuAsEQg24vRVZTzn6vVGTyumiur+ATf6KmjGJqrq8YP+bWphreOt5Dy4FO1i7P3VK0ZrMp6QfrydIVIM4Cy5RSlmjtwQIsjW4fp7Xujvv6GaXUWeAKYHeaygEsnOUAZ3P9hsX86oWTPLOvs6ADRKa5RyM3flexbcb9Spw2TCZwjxZWH8TQiI8w008SXKhmW3XyqrW12K2altYLOQ0Q85GWPgit9UXgAHBfdNN9wFtaT1y0Vim1LO7rzcAqQKejDPHyeQWrbLLbLNy6dTn7j/dwumso18UxLLcncsN3FU8/BwIigwNcxXaGRgprYEB/NIW5dFLPjdNhZfPaGvYduzghK6yRpHMU02eBLyqljgNfjH6PUupJpdTV0X3+h1LqsFLqbeCHwMfjaxXpslAW80jGHdfW4yq28eizJwp6MZtMco8kV4MAKCu2FVwNIvb7l80SIMVU121YzLDHz5EzfbkuSkrS1gehtT4GXJdg+11xX9+fruPN5J4djfz490cJxt0QjTzUbD6cDisfunkN//r7o/zu1TO8/4aGXBfJcGI3/NlqELF9hgotQIzXoGYPkGKiKxqqKXZYee3IBTY1Gi8XXGHN5ona1lzHs/vO0t7tJhSePTVAoXvHFXUcOdPP46+cBuDd21ZitUQqjz5/kPYLbs50uRkZ81PpcrCpsUaGNMZxe/xYzCaKi2b/uJSV2Dl9vrCa82JzaUqdEiDmymY1s1XV8vqxi3j9QRw2Yy1WVpABAiIda1vVIj539xW5LkrOmUwm/std6wgT5vFXTvPC/k6W1pTg9vjp7h2dUNMCsJiPc9s1K1hWU8JjL7dNGKWxEIPs0EhkFnEyWT1dxTYGC60GMerHajFTVKArMWbadRsW8/LBLg6e6uWadYtyXZw5KcgAMTjspXfIy7uuXjjpNWZjtZj59Hs2cP2GOvYe6ebS4Bg1ZUVctbaGhiVlNCwpo6zETnfvKH94vYM/vNaByQSxdYfiVxFbaEHCPepPqnkJoLzEjtcXNOTT4nSGR/24im2GHcufa+vqIwkL//WJI/x/jx021MNWQQaItuiInYYlEiDimUwmNjVWs6lx+sSFS2tK+NRd63nreA8jY4EJP1uIQ4Uh0gafbPt7LJC4R304ygtj9cJhjx+XNC+l7LWjF/D6AuM5moz0sFWQmbdOdw1hNplYWWesWZ/5ZHJwiFloQ4UhMoon2QBRNh4gCmeoq3vUR6l0UKds1+5TUxL4xR628l1hBojzQyyvLSmYKn4uyFDhy9weX9JDPF0lkRvpUAEl7HN7/NJBPQ9GnpdVcAEiFA7T1uWmYak0L81HosXoF+JQYX8ghMcbnHMNopCGug7PoQ9GTGXkh62C6YOIX90JIByWSWHzMXkxeoB3v2MlAF99aM+CGdk0lzkQUHhNTIFgiFFvQPog5uGeHY1TFhMyysNWQQSIycn5AF493I2qryzom1emxXLNjI4F+JuHX2XfsR4u9I1OWUUrtm8hupyHKbkA4bBbsNvMBdPENOJJfha5SGzyw5bVYjJMCvCCaGJKlJwvEAwbohPICIqLrNx1/UrOXhyeNglioUplFnFZAc2mjgXIUmlimpdtzXU8+PntfHDHagLBMKsMMoCmIAKEkTuBjGKmTspCPs9zycMU4yq2FUwT0/gs6iRmkYvZ3bBxCRazief3n8t1UZJSEAHCyJ1ARtDS2s1/PHN82p8X8nmO9UGUlST/BO0qthdMwr5Rb2S4c3GRNDGlQ3mpg2vWL2LPoS483sRDyfNJQQQIGXGTWYma8GIK/TyP52FyJP8E7XIWTg1iZCzye5RIDSJt3rV1BWO+IK8eTnsi67QriACxrbmO++9cN55MraLUbphOICOYqQmp0M+zezSSh2kuaSYiNQh/QYyk84zFahASINJl9dIyVi8t44+vd+T9OhEFESAgEiSubKymvNTOv3xhe0HftLJtpia8Qj/PQyNznwPgKrYRCIYY8wVn3znPjYwFMAFFc6hBidm9b3sDlwbHeOVgV66LMqOCCRAAbV1uVi8pk6RiaZaoCQ/g+gIPDjC3PEwxsbQUbo/xm5lGvQGcDmtSmWxF8jaurmLNsnJ+9+oZvP78fZAomAAxMubnQt+oJOjLgFgTXqwmUeWyU+ywcrJzMMclyzz3aPJ5mGLiE/YZ3eiYX5qXMsBkMvGnNzXS7/by2z2nc12caRXMXz625rKk2MiMyQu0P7PvLI8+e4Jj7f2sW1mZw5Jllns0+TxMMYU0m3p0LCABIkOaVlRw46Yl/PG1s1y3fjH1i/NvbkTB1CBiq3g11EmAyIYdVy6lvNQ+vkodRIbDfvWhPXzqgef56kN7aGnN/1EaM5lrHqaY2P6FUIMY8QYokSGuGXPvzWtwFdt4+PFWxnz5N+y1YB4N2s4PUVdVLE87WWK3WdiwqoqWw9186oHnKSmy4PWHCAQjI3cKIQ3HsGduaTZiYgFiuABqEJ6xAOVVxbkuRsEqddr4zPuaefDnb/HIHzSffu+GvOpDLYgaRCgc5kTnIGuXl+e6KAtGS2s3+45eGP9+ZCw4HhxijJ6GI5ZPaa4BwmGzYLOaC6KJaUT6IDJu3cpK7r5xNXuPXMi7GdYFESDO9Yww6g3QtKIi10VZMHbtPoU/OPs4fyOn4UglDxNEOiAj6TaM38Q06pU+iGx497aVXNlYzc+fO8GJzoFcF2dcQQSI42cjJ1RJgMiaZG/8Rk7DcTmT69zb4F1Ou+GHuQaCIXz+kKTZyAKzycSn37uB6vIiHvrNYQaG8+PBqiAChD47QHWZg5qKwlgD2AiSufEbPQ2He2TueZhiCqEGEVt2VtJsZEdxkY2/+MBGPL4AP/htK6E8mIlv+AARDoc5fnZAmpeybLrJc05HZJnX6jKH4dNwpJKHKcZVbGNoxNg1iNFoHqZUfn+RmuWLSrnv1rUc6xjIi1nWhv7Lt7R288vnTzA04ufgqV5aWrsNfUMyksmLoFSW2vEGQpSX2Pl//uKaglgPPJU8TDGuYvt4H4ZRXc7kaujbhOHceOVSWlov8KsXTrKlqTan64Eb9i8/eRW5kbGA4YdVGs3kyXOtZ/r4l58f4JfPn+Tjd6gcliw9UsnDFOMqtuHzh/D6g4YNlrF01E6pQWSV2WTiY7c38fV/fZ2nXmvn3pvW5KwsafvLK6WagJ1ANdALfEJrfWLSPhbg28CfAGHgAa31j1I5XqIU1LFhlRIgcqN5VRV3XLuCP75+luaGKrY01ea6SPOSSh6mmPh0G45yY/aNjXkjOYKcdgkQ2ba8tpTrmhfz3L5O7ri2fs6z+dMlnX0QDwPf01o3Ad8Dvp9gn48Ca4C1wDbgG0qpVakcTFaRy0/3vLORlYtd/OTJo/QNjeW6OPOSSh6mGJczNpvauP0QnujM3iK7MWtARvfubavwBULsPnA+Z2VIS4BQSi0CtgCPRjc9CmxRSk1+hPww8EOtdUhr3QM8BtybyjFlFbn8Ekuz8Zlvvcjg8Bhef5Af/O4IoVDuR2KkKpU8TDGuEuPnY4rVICTVd24sqymheVUlL+zvzNm6EemqQawAzmmtgwDR/89Ht8erB9rjvu9IsE9S7tnRyOSuQ6MPqzSqWH9QrPY2MOInHI7MT3ni1TO5LVyKUs3DFFMI+ZjGpAaRc7dsXc7AsI/W0305Ob7hHg2qq0sB2NgUIswRSpxWRj0BaiqdfOLO9dy0NaV4Y0i1tfmR/fGxV1qm9AcFQ2Ecdgu/3XOa7VuWs25lVUbLkG7sljkAABq3SURBVO5z0TvoAWDp4rKU3ru4tAiAsNmc9b9Tuo5nsliwW80sqTNuCpt8+Yyk6paqEn76lOatk728a1tD1o+frgBxFlimlLJorYPRzuil0e3xOoCVwBvR7yfXKGb1lf+9m3duXspbx3tw2C088JltE7JN9vS4U/4ljKS21pU3v2tPvyfhdq8vSKXLwXd+/hZ/98mrsZgzM+0mE+eivTv6fsFQSu8dDoexmE109biz+ndK57noG/RQZLfkzXU2V/n0GZmPq9fV8srBLjo6+1MaUWY2m8YfrOf82pReNYnW+iJwALgvuuk+4K1oP0O8XwGfVkqZo/0TdwO/nsux+oe9/OT3R9mne/iTa+slFXEemKk/6L5b19JxcZgX38pdR1sqUs3DFHM5H5OR+yACFMkIppzbtqEOfyDE/uOTb6eZl85Hus8CX1RKHQe+GP0epdSTSqmro/v8G9AGnAD2At/UWrfN9UCBUOTp7K7r69NTcjEviWZVx/qDtqpa1tVX8Ns9p/EaaI3m2I09lTQbMa5iu6FTfo/5ghQ5pP8h1xqXlVHpcvDWiUtZP3baHg+01seA6xJsvyvu6yDwuXQcLxgKY7PKxZsPJs+qri5zcM+OxvHtH3jnav7nv+/n+bc6ufO6lbksatLmk6gvxuj5mDxSg8gLJpOJuqpi9h/v4VMPPD/l85VJhv3ry3DW/DJ5VnW8tcsraF5VyVN7O7h1y3LsBphZ7B71pZyHKcZVbOfSwFAaS5VdY74gFaW5maAlLmtp7ebE2cspwLO5GJchk/XJcFbjuWvbKoY9fl4/ejHXRUmKe9RHaXFqeZhiXE6bofMxeXwBmQORB3btPkUglJvFuAwXICpLjZ8ldCFaV1/B0poSntvfSTgP0hjPxj3qx+Wc39Ozq9iGxxvEH8jNJKf5GvMFccociJzLZdYIwwWIv/34VgkOBmQymbhlyzLau920deV/s8vQaOp5mGLi8zEZkYxiyg+5zBphuAAhjGtbcx12q5lXD3Xnuiizco/65zWCCeJnUxtvJFMwFMIXCMkopjww0yjBTJMAIbLG6bCyeW0Nbxy7mLPcMsmKNDGlqQZhwH6IMZ9kcs0X25rruP/OdVS5IteT3WrOWjO7BAiRVdua6xj2+DnclpvcMsmI5GEKpKGJybg1iNhaEJKHKT9sa67jW1+4ge0b67BZzVy3YXFWjisBQmRVc0MVpU4be4/kbzPTsCc6B2LeTUzGzeg6XoOQUUx5ZcOqKkbGApy9MJyV40mAEFlltZjZ0lTDobbevG1minUqz3cUU3GRFbPJZMhO6vFU31KDyCsbVlYCcORMdmrgEiBE1hU5rHi8Qf78wRf56kN7aGnNr9rE0Oj88jDFmE0mSg2aj2k81bfUIPJKeamDZTUlEiBEYWpp7eaFNzvHv4/NCs2nIBG7oZfPs4kJjJtuw+OTGkS+Wr+qkhOdg/gDyeU2azmc+mdLAoTIql27T+EP5mZWaLLcI7EaRBoChNOG22PAGkS0k1pGMeWfDauq8AVCnDyX3Hyi/SdTT/InAUJklRHWEh8c9WG1mHCmYQ6Aq9huyCam8RqEzIPIO2pFBWaTKalmplAoTNelkZSPJQFCZJUR1hJ3j/hxFdvnlYcpxlVsY9iATUyy3Gj+OnDyEmYz/L6lfdY+vK6+UXz+1NPsS4AQWZXLWaHJGhr1UZaG5iWI1CBGxgJ5O2JrOmPeIHarOWOrAIrUxNZ/D0SbaWfrwzszz7Q28tcXWRWbFRpfY7jvXWvzKr+We9SHqyQ9KxXGRkKNGKwfYswXkNpDHtq1+9SU9d9n6sM70+WeV3p96YESWRdbO0J39PNPP3srbU/r6TI04mdJdUla3it+slx5af40o83G6w/ikACRd+bah3e6e4jltalfy1KDEDnTuKwch83C4SyN6U5GOBzGnc4mpmg+pyGD9UN4/SEcBljYaaGZSx9eIBii48Iwy2tLUz6eBAiRM1aLmXX1FbSezp8A4fUH8QVC6WtiKjFmug2vLyABIg8l6sOzWUwJ+/DO9YwQCIZYsUgChDCo5oYqLvZ7uDjgyXVRABiK3sjT10kdS9hnvBqEEZaGXWgS9eG9Y+OShH14xzsjy5TWL049QEgfhMip5oYqAI6c7mPRVctyXJr0TpIDKC2yYcKANQh/cN6pRkRmxPrwQuEwf/3dPdMOgDjW3k9tRRGVrqKUjyU1CJFTdVXFVJU5OJwnzUyxvoKyNDUxmc0mSgw4m9rrC0oTU54zm0xsaarlYFvvlLkOoVCYYx0DrI8m90v5GPN6tRDzZDKZaF5VxdH2foKh3M8VcKe5iQmMmY/J6w9KE5MBbFG1+PyhKQ9Y7RfceLwB1q+smtf7SxOTyLnmhipePtjF6S43a5aV57QsQyPpyeQaz4jpNrz+oMyDMAC1ogJXsY09h7rY0lRLS2s3u3afGh/2OjI2v+tOahAi5zasqsIEeTGaaWjUh9NhwWZN383RaDWIcDgsNQiDsFrM3LBpCQdOXuKZfWfZ+dSxCXMifvn8Sfaf6En5/SVAiJwrddpYtcSVFwHCPepPWwd1jNFqEP5AiHAYHDa5PRjBTZuXQRh+81JbwlnWf9zbkfJ7yxUg8kJzQxVt54cYHQvktBxDI+mbJBfjctoY8fgJhcKz75wHvP7YWhDSAm0EtRVOtm9aMr5M7GT9w6lnSp73FaCUKgZ+AmwFAsBXtNZPJNjvJuBJ4Hh0k1drfd18jy8KQ/OqKp54tZ1jHf1saarNWTncoz5qK5xpfU9XsY0wMDzmz7u0IonEAoRdahCG8aGb19ByuJtggoeQynmkeEnHFfAVwK21XgO8F/iRUmq6mRlHtNabo/8kOIhxsbQbuW5mGspQExMYZy6EN/okKsNcjaPUaeNjtzdhMU9MUW+3mrnj+vqU3zcdAeLDwMMAWusTwD7gzjS8r1hA8iHtRjAUwj3qS8tSo/FiI6KMsi6E1x9px5YAYSw7Ni/jU+9ePz7LurrMwf13rmPL2tRr5OloZKwH2uO+7wBWTLNvk1JqP+AHHtJa70zD8UWBaG6o4u1TvVzsH2VRZXHWjz804icchorS9AaIWLPSkFFqEH5Zj9qoYrOs02XWABG9oU9XR1k8h2PtB1ZorQeVUg3As0qpc1rrZ+fwHlRXp55XpNDU1rpyXYS0unHrCn727Ak6Lo3S3DSXSys952JwLHJjrF9WkdZza3dGAkSA7PzN5nuM0z2RJSoXL3IZ/hozevlzbdYAobXeMtPPlVIdwEogNti2HnghwfsMxX19Win1GLAdmFOA6O0dNsxokEyqrXXR0+POdTHSyk6Y6jIHew91cfXamqRfl65zcfpsPwCmYCit5zYcDmO1mDnbNZTxv1k6zsXFnmEARoe9hr7GCvEzkgqz2ZTyg3U6+iB+BXwGQCm1FrgG+MPknZRSS5RSpujXVcDtwIE0HF8UCJPJRHNDFUfb+3KSdmNgJDIcMN1NTCaTiUqXnQF36sMNs0mamERMOvogHgR+qpQ6CQSBP9dauwGUUt8EzmutHwY+CHxOKeWPHvcRrfXjaTi+KCAbV1fz0ttdHO8YYP2q+eWRmavBYR8moCzNndQQGWrYn0SAiE+VYDGb2Li6ii9+cBMmk2nW16bL5WGuEiAWunkHCK31CHDvND/7WtzX3wW+O9/jicJ2RUM1dquZfcd7sh4gBoa9lBbbsFrSP/6/wuXgTNfMzR2xBeljs2GDoTAHTvby692n+NOb1qS9TNORYa4iRmbCiLzisFvYuLqa/cd7CIWz29c0OOyjIkPrRle5iugf9hKe4XdKtCA9wHNvdmakTNPx+oOYTSasluzVWkR+kgAh8s5WVcvgsI+280Oz75xGA8NeytPc/xBT4XLgD4QYmSGVyHQLz3v9oawOzPD6gzjslqw2a4n8JAFC5J1NjTVYzCbe1BezetyBYS8VJZmqQUTed6Z+iOkWpAc4d2kk7WWaTmSxILk1CAkQIg8VF1nZuLqa145cyNpoplAozNCInwpX5moQMHOAuGdHI9ZJqRJs0Wae9u7sDdf0+mU1OREhAULkpRs3LWFg2MfBU71ZOZ571EcoHKY8wzWI3qGxaffZ1lzHpjXV49/HUiU47BbaL2QvQPj8IRwyxFUgK8qJPLVpTTXlpXZeOnCeq+aRSyZZA8ORPEnpngMRU+FyYLWYuDTgmXG/YU+AVXUuvvbJa8a3vXjgPB1ZDBBSgxAxUoMQecliNnPDxiUcbIvkZsq0geHYJLnM1CDMJhM15U56ZggQPn+QtvODqPqKCduXVBVzoX/mwJJOYz4JECJCAoTIW7dsWY7FbOb3Le2z7zxPfdGmn6qyoowdo7bCSc/A9E1MbeeHCATDqPrKCdsXVToZGvHh8WZnMSVfdBSTEBIgRN6qdDnYsXkprx7uzvgontjM5UwNcwVYVOHk4oBn2rkQxzr6MZmgaXn5hO2Lo5ltZ6p9pJM0MYkYCRAir713+yqK7BZ2/uFYRucC9A2NUelyYM7g2P/aiiI83sC0cyF0xwD1i10UF9kmbF9UGVnh7mKWmpmkiUnESCe1yGtlxXbue9dafvTEUX7+3Anue9daTCbThJxFtZVO7r6hYV558C8NjVFTnrnmJWB8KdOeAQ+lzolBwB8Icur8ELdsWTbj67LBJzUIESUBQuS9d1yxhI4Lwzz9xlmGx/ysWVbOL58/OZ6Woqffw86njgGkHCT6hsZYN6ntP93ib/QNS8om/CzS/xBKWAanw4rTYaUvC9lgQ+EwvoAMcxUREiCEIXzoljUUO6w8vuc0e1svTPm5LxBi1+5TKQWIYChEv9ub0Q5qgMVVTkwmOJ+gP+VYxwAmoGlF+dQXEplH0TfDHIp08fklUZ+4TPoghCGYTSbed0MD//B/XjftPtPlMprNgNtHODxzqot0sFktLK4s5lzP1AChO/oT9j/EVLqSSxc+X5czucqtQUiAEAazpLpk2ht5RUnim+tsYrObqzNcgwBYVltC56QaRKz/YfL8h3iVLkdWmphia0FIE5MACRDCgO7Z0YjdOvXSDYVh2OOf8/vFOn9ron0EmRQOw4W+UT71wPN89aE9tLR2c7xzEH8gxLqV0/eBVJUVMTTiIxDMbG4qrz/y/tLEJEAChDCgbc113H/nuvGaRG2lk/dtX8WoN8Ajf9Rzfr8L/Z7oTOfM1iBaWrs5ePLS+Pe9Q152PnWMp1/vwGoxsX6GTvLKaC6n2IzvTJHFgkQ86aQWhrStuW68Qzq2OL3FbOI3L5/mF8+fYN+xi/QOeakuc3DPjsYZO68v9o9SXe7IyEpy8XbtPkVg0lwOXyDEkTP9rKuvmLFZp6w4MoHPPeqnpjxzNR1vQJYbFZdJDUIUjDuvX0lZiZ2nXz873mEde0pvae2e9nUX+jzjs5UzabpO9GAozBWrqxP+LMYV7V8ZGvGlvVzxZBSTiCcBQhQMq8VMKBRi8nzr2BDYRMLhMBcHRrMSIGYaJWUxzzyDO1aDGBrNdICI9EHYZRSTQAKEKDDDnsRpLBI9vbe0dvOV7+3B4w3S0to1Yy0jHabrXAf4zxdPzXj8+CamTPLFmpisUoMQEiBEgZnuKb2kaOINr6W1m51PHaM/ug7EqDc4a1PUfMU61xNVFmaq5UBk2KndZs5CE1OkBmGTGoRAAoQoMPfsaEx4UXv9oQk3/127T42n6oiZ7SadDtua65gu5+BsE/3Kiu24M93EFK1BOKQGIZAAIQrMtuY6bAk6WAPB8ISb/3Q341RnY8/FdLWc2WZyu4rtDGW6iUlqECKOXAWioLS0do/PBp4s/uaf6k06HRL1RditZu7Z0Tjj68qKbbgz3cQUCGKzmjOa9lwYhwQIUVBmaiIqdV6e9nPPjkZslok3wWRu0ukweaJfdZmD++9cN2uiQVeJPSujmKbrSBcLj0yUEwVlpiai+JXctjXXMTjs5ZcvRAJKMhPq0il+ol+yIn0QfsLhMKYMPeH7/EGZJCfGzTtAKKU+BvxXYAPwJa31d2fY99PA3wAm4CngL7XWmU0uIxaU6jLHtEFiZGxi01NFNH3F1z95DSvrXBkv23yVFdsIhsKMjAWmLDiULr6A1CDEZem4Eg4AHwF+NtNOSqkG4OvANmBt9N/H0nB8IcbN1EQ0uX/heMcARXYLyxeVZLpYaVFaHAkKIykkJEyW1CBEvHkHCK31Ya31EWC2msCfAo9prXuitYYfAh+e7/GFiLetuY6br1o6ZbvZNDV46LMDNK2owGI2xhNzSXStiOGxDAYIqUGIONm8EuqB9rjvO4AVWTy+WCA+fsc6Pv3eDeM1BrvVjM1q4WpVO77Pxf5RunpHWT9Diu18UxJtVhodSzxbPB2kBiHizdoHoZTaT+TmnshirXXiMYUZUl1dms3D5bXa2vxvN8+WyefifTe5eN9NawF4+3gP//f3X+Vo5xC3XhO5lHcfikyau31bA7VVmc/DlA7eaB+72Wad8W8/n+siBJSW2Avm2iqU3yNXZg0QWustaTpWB7Ay7vt64Oxc36S3d5jQdFNRF5BYimsx+7lYUuGgfnEpO39/hLVLXNisZp54uY01y8sxBYOGOY/e6BDX7ovuacs83+ti1OOnqtRhmHMyE/mMRJjNppQfrLPZxPRr4G6lVK1Sygx8GvhlFo8vFiiTycTH71AMuL386Ikj/PL5k/QOjXHX9Stnf3EeKS6KPM+NZLIPQuZBiDjzvhKUUvcppTqBe4G/V0p1KqU2RH/2TaXUZwG01m3A3wN7gRNAG/Dv8z2+EMloXFrOh29dy1snLvHsm52888olXNk48xoM+cZqMVNktzAyTcbadPAFpA9CXDbveRBa60eBR6f52dcmff994PvzPaYQqbj9mhVsXlPN4IiPNcvKMzbZLJNKiqyMZroGIXmYRJTMpBYLyqLKYhZlYXGgTCkpsjGSoVFM4XA4MopJMrmKKHlUEMJASpy2jM2DCATDhJHV5MRlciUIYSDFRdaMzYOQ1eTEZBIghDCQkiJbxlJtyHrUYjK5EoQwkBKnlZEx/4TMtOnii66jIaOYRIwECCEMpKTIRiAYnrJcajrEFlqSJiYRIwFCCAMpiU2Wy0Azkz8gTUxiIrkShDAQpyMSIDze9HdUjzcxyUxqESVXghAGUjweINKfI9M7XoOQJiYRIQFCCAMpigUIXwZrEBIgRJQECCEMJJNNTON9ENLEJKLkShDCQJz2yNN9RvsgpAYhoiRACGEgzkz2QfilBiEmkitBCAMpslswkaEaRCzVhgxzFVFyJQhhICaTiSKHNWN9EBazCYtZbgsiQq4EIQym2GHJSIDw+mWxIDGRBAghDKbIYcXjS38fhCwWJCaTq0EIg3FmqInJFwjikDxMIo4ECCEMxmnPUIDwh7BJDULEkatBCINxZqgPwheQ5UbFRBIghDCY4gz2QTikBiHiyNUghMFkapirT0YxiUkkQAhhME6HFX8gRCCY3kWDfIEQNplFLeLI1SCEwWQqH5PPL30QYiIJEEIYTKYyuvoC0gchJpKrQQiDydSiQdIHISaTACGEwRRlqgbhlz4IMZFcDUIYTHEGVpULBEOEwmGpQYgJrPN9A6XUx4D/CmwAvqS1/u40+90EPAkcj27yaq2vm+/xhVhoihzp76T2RdeCcEgNQsSZd4AADgAfAf5bEvse0VpfnYZjCrFgZWLRoMtrQUgNQlw27wChtT4MoJRK76DsqSwAZrMpw4cxDjkXly2kc1HqtLGo0onFbEr4e6dyLsLhMIsqnZSX2gvqXBbS75KquHMw5+hvCofDaSmEUuqnwL5Zmph+C5wE/MBDWuudczjEDcDL8yymEEIsVDcCr8zlBbPWIJRS+4H6aX68WGudbD13P7BCaz2olGoAnlVKndNaP5vk698g8gt2AelPRCOEEIXJAiwhcg+dk1kDhNZ6SyolSvA+Q3Ffn1ZKPQZsB5INEF7mGP2EEEIAcCqVF2VtyIJSaolSyhT9ugq4nUgHtxBCiDw07z4IpdR9wINAJeADRoDbtdZHlFLfBM5rrR9WSv0F8Dki/Q9W4BGt9T/P6+BCCCEyJm2d1EIIIQqLzIoRQgiRkAQIIYQQCUmAEEIIkZAECCGEEAmlIxdTViilmoCdQDXQC3xCa30it6XKPqVUNfBvQCORuSEngc9orXtyWrAcUkp9HfgGsDGW+mWhUUoVAf8LeBcwBrRorf88t6XKDaXUe4C/B0xEHoK/obXeldtSZYdS6lvAB4FVxH0eUr1/GqkG8TDwPa11E/A94Ps5Lk+uhIF/1lorrfUmIhNgHshxmXJGKbUFuB7oyHVZcuyfiQSGJq31RuDvclyenIjOtfo34ONa683Ax4CdSikj3evm4zHgnUD7pO0p3T8NcdKUUouALcCj0U2PAluUUrW5K1VuaK37tNYvxm3aC6zMUXFySinlIHKxf55I4FyQlFKlwCeAv9NahwG01hdyW6qcCgHl0a8rgC6tdaaTieYFrfUrWuuz8dvmc/80RIAAVgDnYnmfov+fj25fsKJPRZ8jkgRxIfom8O9a69O5LkiONRJpNvi6UmqfUupFpdQNuS5ULkQD5IeAx5VS7USeqO/PbalyLuX7p1EChEjsO8AwkDCDbiFTSm0DrgEeynVZ8oAVWA28FV1v5W+AXUqpstwWK/uUUlbgb4H3a61XAu8FfhGtZYk5MkqAOAssU0pZAKL/L41uX5CinVFrgQ8vlOrzJDuAdcBppdQZYDnwR6XU7bksVI60AwGiTQha69eAS0BTLguVI5uBpVrrPQDR/0eA9TktVW6lfP80RIDQWl8kktjvvuim+4g8LS3IkTtKqX8EtgJ3a629uS5PLmitH9BaL9Var9JarwI6gTu01k/nuGhZp7W+BLwA3AbjI1YWERnhttB0AsuVUgpAKbUeqCPFbKaFYD73T8PkYlJKrSMyTKsS6CcyTEvntlTZp5RqBg4TWdvbE918Wmv9gdyVKveitYj3LOBhrquBHxMZxugH/rvW+qnclio3lFIfJbIEcqxm/XWt9WM5LFLWKKW+DdxDJCheAnq11s2p3j8NEyCEEEJklyGamIQQQmSfBAghhBAJSYAQQgiRkAQIIYQQCUmAEEIIkZAECCGEEAlJgBBCCJGQBAghhBAJ/f86ueYxT4B3WAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = make_pipeline(GaussianFeatures(30),\n",
    "                      LinearRegression())\n",
    "model.fit(x[:, np.newaxis], y)\n",
    "\n",
    "plt.scatter(x, y)\n",
    "plt.plot(xfit, model.predict(xfit[:, np.newaxis]))\n",
    "\n",
    "plt.xlim(0, 10)\n",
    "plt.ylim(-1.5, 1.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With the data projected to the 30-dimensional basis, the model has far too much flexibility and goes to extreme values between locations where it is constrained by data.\n",
    "We can see the reason for this if we plot the coefficients of the Gaussian bases with respect to their locations:\n",
    "\n",
    "通过将数据投射到30维的空间上，该模型太过于灵活以至于当处于间隔距离较大的点之间的位置时候，会拟合成很极端的数据值。我们可以将高斯函数的系数也绘制在图表中，就可以看到原因："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbEAAAEMCAYAAABKhIgaAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOy9eXhbZ5n3/9Fiy7Ity7Is2Y63OIl9sidN0jbpSoECXSltgVIoSxmWH9uwzsqPYZiZF4bhZdgHaCmUlrZT2gJNF7qvadomaVYnOXFW75YsW7Jl7dJ5/5DkVbK1eZH9fK7Ll23p6NHjY0nfc9/P97lvlaIoCAQCgUCQj6jnewICgUAgEGSKEDGBQCAQ5C1CxAQCgUCQtwgREwgEAkHeIkRMIBAIBHmLdr4nsAjRAecDPUB4nuciEAgE+YIGqAH2AP5UHyRELPecD7wy35MQCASCPOVS4NVUDxYilnt6AAYHR4hExB48s7kUh8M939NYEIhzMYY4F2OIcxFFrVZhMpVA7DM0VYSI5Z4wQCSiCBGLIc7DGOJcjCHOxRjiXEwgrWUYYewQCAQCQd4iREwgEAgEeYsQMYFAIBDkLULEBAKBQJC3CBETCAQCQd4iREwgEAgEeYuw2AuyZndrL4+8dArHkB9zmY4bL1/JjnXV8z0tgUCwBBAiJsiK3a293P3kcQKhCACOIT93P3kcQAiZQCCYdUQ6UZAVj7x0alTA4gRCER556dQ8zUggECwlhIgJssIxlLhOZ7LbBQKBIJeIdGISJEn6AXATsBzYIMvykfmd0eyS6bqWuUyXULDMZbrZmKZAMO+INeCFhYjEkvNn4DLg3HxPZLaJr2vFxSi+rrW7tXfGx95w2QoKNKoJtxVq1dx4+cpZmatAMJ9k814RzA4iEkuCLMuvAkiSNN9TmRXGX02qVTC5/mh8XSvZFWaPY4Sn93Sw97iNYHjswWoVXLi2igvXVs3m9AWCeWG6NWARjc0PQsRmCbO5dL6nMAVFUei0uXnmjXPsfPUMoXD0zZisgPbAkB+LxTDh8fc+eYw/v3yKQDD62LXLK3jX9kZMhiL6BkZ4bm8HrxzqYcQf5u9u2wYwYYyljjgXY+TjuUi21jv5vZIu+XguFgpCxGYJh8M9L+0VEuXrpfpynt3Xye4jvbhGAimPpVLBoy+2sabRxIG2fh7bfZaBSW/ik51OLh6pZuNyE/VmPVtXmfntE8d59XAPt3zzCVQqUBTE2gHRDyq7fXi+p7EgyLdz4fWH+MMzJ5LeX6LXpv33xN+rA0N+KsT7A7ValdHFvxCxRUSiPVt3PX4MlQoiEdi0ysymVZX8LraPayYiCtyx8+jo7xq1asoxk1Mprx/t481jfaP3KzEdF/vH5gcl9g9Qqab+7wSp4fYG+f59b9Hd72HjSjOtZxyEJ2YU8XhD7G7tTfm1ney9evBkPxesqWJdUwW6Ak2u/5RFiTB2LBJ2t/bym8eOTsnXhyMKiqLw3c9s54s3beSyTcvSdg4W6zR8+xPnE04SWY5PsSRaM4gj9o/NLbZBD9/6zZt87ocv88rB7vmeTl4SjkT4ycOH6B3w8uUPbOTL799EUeFUcYkAD71wMuVxE71PwhGFN4/Z+Nkjh/naz3bx9JvtollmCggRS4IkST+RJKkTqAOelSSpdb7nlIz4VV2y13s4Aie7XKO/33j5Sgq1E//1k38fj8cfpqHKkFT8xt8+0/4wsX9sbghHIvz0kcM43X7qraX87snjnO4emu9p5R1PvN7OyU4Xt1+zmvVNZgBGfIkbDw+6AwwM+ZKOtbu1l2/8Yhe3f+/5ad8H37hlMytqy3jg+ZP84IH9uL3B7P6IRY4QsSTIsvwlWZbrZFnWyrJcLcvyuvme02Tib4o7dk6NwCYzPgLasa6aj121elR8zGW6Cb9PJn57MvEbb6efKcoT+8fmhteO9NJlH+HjV63mKx/YhKGkkIdeTD1SWEyMF49v/GJXynb49r5hHn31DBessbJ97ViaMNlrWAV899599A14Es5hvDU/GeYyHWuWV/CV92/i9qvXcLLLxX/8fu+04rjUEWtiecrknPpMTH7z7FhXnTB/P3nM8SIVP366jZ43Xr4y6bzUKsT+sTlAURSe39dFraWELS0WVCoV7zq/nodePEWPY4Qac8l8T3HOyLS2Zygc4a7Hj1GiL+Aj75q4zSbRa7xQq+aaHY08s7eT7967j8++dz2rG02j90+XZh8/Rvz9oVKpuGRjDVaTnh8/dJDv/G4ParUKpzuQtklqsW/OFiKWZyiKgtcf4sHn21IWMEgtAkpFpJKJX7Ix1GoVkYiCrkBNIBihuqI45TkLMqPb4eFc3zC3vrN51NBx8YYaHnnpNK8d6eWmJXAhEY5E+MurZ3h897lRc1GcQCjC/c+eSPg6Hv+BD3Dl+fWU6gsmHDPd+2Tbais/eegQ379/Pxetr2bH+moM+oJpIzAVJHUnttSXc+X59Tz66tnR29IxSd3z1HFe2D+2HroYDVZCxBYwoXCEgycdHDzVT4fNjcvtx+0NEgqnt9ibTgWNmUQq3THiVmqPL8Q/3/k6dz95nG9+bBtajchkzxYH2uwAbJWso7cZSwpprjNy8KRjSYjYH184xdN7OpLe707gJkyU3XhpfxfLqw1T3hPJ3ic15hK+/YkL+POrp3lhfxevHZk+dWku0/G7f3nPtPb8XYd6ptyWygbr3a29EwQsncfmE0LEFigHTvbzh6dlHEN+Soq0LK82UG8txVBcgEFfyBOvn8XtDSV8bEmRBpVKhdsbWjDpg+IiLR+5soWf/+kIz+zp4KrtjfM6n8XMgbZ+llcbMBkmRt+bVlXy4AsnGRjyUVFWNE+zm3267G6e3tOBrkCNP5g8WzE5GstVNQ5doYYPvr2Z6y9u4nT3EF5/iJ6BER7bdXZCdZtULy4zLbI9nRN4MRmshIgtQHa+dpY/vXyaOksJX7pZYsOKCjTqiZGLsbQwYV7+Y1etnnfBSsZWycqWFgt/fvUMWyQLVSaRWsw1w54Ap7uHeO8lTVPu27TKzIMvnOTgKQdXnFc7D7ObXSanAqcTMJgajeW6I4Nep2VdU8Xo75VGfU6LbJcWaVEUJekewOnmvZgMVkLEFhjP7OngTy+fZse6Kj5+1RoKkljfU1m/Woh8+MoWvnnn6/z+rzJfv2Wz2ISbY052ulBggqkgTnVFMSaDjhMdzkUnYukaneKMj7JK9dqE2Y1cfeBnmqpPZCRRAW5fiO/e+xZvO28Zq2qNFBVqGRoJcK5vmFNdLjRqVdK9nYvJYCVEbAHRenaA+59rY2uLhU9esxZ1ggoZ48nF+tVcYzLouPltq7jnKZldh3u5ZGPNfE9pUdHW6UKrUdFUM7UWn0qlornOSFuncx5mNruk4v5LRDxa2Sfb8fjDqIDxH/sLoSNDogvWGy5dQSgcYedrZ7nzsWNTHqPXaaiq0NPr8EzZP6pWwbFzgzz84kkGhtN3Oy40hIgtEEZ8Qe56/Bg15mI+dd3MApbPXL55Ga+39vK/z7exYaUZY0nhfE9p0XCi00lTTRkF2sQli5rrynnzmA2Hy4fZuHjWxWZKnSW7X1eg5kd/PMihUw6aasq4ZGM1T+w+t+CyG8kuWC/dtIxzvcN094/gC4Qp1RdQZy2lxlyMWqVid2sv9z97YjTC1OvUFBUW8Oo4s0i+OxaFiC0QHn7xFC53gC98dCuFi7xmmlql4uNXreZf7nqT+589wWffu36+p7Qo8AfDnOsd5t0XNCQ9ZlWtEYC2TidmY/59YCVjuuas//W5ixOmG9Wq6Guxu3+E6y5azrUXNVKg1XDFeXVzOfWsUKtUNNWU0VRTlvSYwLi1Qa8/gtc/9Tzls2NRiNg8s7u1lwefb8M1EqSoUEPvgGfaF+RiocZcwrU7lkdNHi19XLBG9B/LltPdQ4QjCi31xqTH1FtLKSxQc7pniO15+IGVjBsvX8nvnjiW1P2Xr2vI2ZJOmjVfHYtCxOaRyVeHvkA4r8P6dLl6RyNHzg7wm8ePYTYWsXJZ8g9fwcyc7o7Wx1wxzXlUq1U0WA2c682fNiipsGNdNSc7XbywvwtI3PonH9eQsyUdYcpXx6LYcTqPTLcvZSmg1aj5wo0bMJYU8sP/PcCJjsVnOJhLOu0jmMt0UypMTKax2kB7n5vI5FIWeY5Wo6ZQq+bOv7uC//rcxUtOsBKRjjBdeX79LM5k9hAiNo/kel9KPlJWXMjf37qFshIdP3hgP4+9dpZAMHGV8GRkWuB1sdFhc1NvnblDcGOVAX8wnLBQbT7T3jdMnbV0UZui0iVZ0e4rzhtryVReUkCBVs3u1j6CofTeewsBkU6cR4wlBbhGprZZyNewPlPMxiL+6SNbuOfpEzzy8mmeerOdjSvNVFUUo1GrGPYEcY0EGPYE8AfCRBQoLy1kZa0RlQr+8sqZtAu8LjaCoTC9Dg9bWiwzHttYHRW6c73Di6YYsKIotNvcXLhWrK2OJ9W1wP1tdn768GG+9ONX8AcjebVmKERsHqks108RsYWwL2U+MBQX8rkb1nPs3CAvHeji2LlBdrdGO0QXatUYSwspKy5EV6hBBfQ4POxv6084Vj47rTKlq3+EiKLQYJ25vXuNuRitRs25vuFFY+7od/nw+kM0VKXf3n6xk8paoC8QRq0aq3KSTxeDQsTmmMmlceqtJXh8oSXlmJqONY0m1sSqTYTCESIRhQKtOmFlj8FhP1/7+a6E4ziG/Nz+veeXzDnt6HMDUffhTGg1auqtpYvK3NHeF/1bGqtmTqcKpvLIS6embIrOl4tBIWJzSKK9Kr0ODx+/es2Cf6HMB1qNGqbZMmcy6KbdyAr5dUWZDR02N4UFaiwmfUrHN1SVsve4bdrae/lEd/8IAMsqF0d6dK7J5/V5YeyYQxK5EYNhZcm4EWeDRAvXk1kKjs8Om5s6SynqFAWptrKEEV8IpzswyzObG3oHPFSU6dAt8kIBs0WydfgKw8KvpiNEbA7J56udhcqOddV87KrVzGRIW8znWFGUmDMx9fWgOkv02C67e7amNaf0DnhEw9UsSHYxaDEVE0lSRHihIERsDkl2tbPU3Ii5Zse66in5/Mks5nM8MOTH4w+lJWK1lmjardM+MlvTmjMURREiliXxi8H4+8RcpmNzcyVyu5M7HztKKJx+ceW5QqyJzSE3Xr6Sux4/NqE9wlJ1I+aaVNbGvvGLXWxcaebQKceiMtJ02FI3dcQxFBdiLClcFJHY0EgArz9MlRCxrEjkYnx891kefuk0vQMePnvDeqzlqa25ziUiEptDzl9tpahQg1YTzX2Zy3QLuollPpHK2phjyM8L+7tHxS5u+sj3zdEdtqgzL54iTJU6Swmd/fkfifXGNm3XCBHLOdfsWM7n37cB26CXf/nNmzzx+rkFF5WJSGwOeeVgNyO+EF/9wCbWrzDP93QWFYk2dfoCIUZ801cgyBcb8XR02NxYyovQ69J7O9daSnlhfxeRiJLXVS76Br0AIhKbJbZKFhqrS7n/2TYeevEUrxzq4dZ3NrNhgXyGCRGbA3a39o42oNNqVAx5FocjbKExOR1y+/eeT+lx+W766LCPpFRuajK1lhKCoQh2pzevBcDu9KJWqahYxOue802lUc8Xb9rIoVMO7n/2BP/94EE2r6rk1nc2UznPKUYhYkmQJKkFuBswAw7go7Ist6U7zuS9YaGwwu//KqNSqfL66j8fmGmdbPxx+Yo/EMY24GF7BuWW4unHTrs7r0XMMeTDZNChUYvVkdlm40ozaxov5Jm9HezcdZZv/3YPf3PtWjY3V87bnPLuvy5J0g8lSdo8B0/1S+Dnsiy3AD8HfpXJIEu9Uv18kso6mUZNXhtrOvvdKKRn6oizrLIEFfnvUHS4fFQuoi7VC50CrZqrtzfynU9egMWk56cPH+KVQ93zNp+8EzGgAHhKkqQjkiT9vSRJOW/DKkmSFdgC3B+76X5giyRJM1dXjfHde/axu7VX7A2bRybbhkuKNEzeCxyOwMlOF0qetiXJxJkYR1egwWLS571Dsd/lwyxEbM6xlOv5hw9vYW1TBb994jhvHuubl3nkXTpRluUvSpL0ZeAq4MPANyVJegP4PfCILMu5eEfWA12yLIdjzxmWJKk7drs9lQEG3VHnm0atmmCpj2Mx6bFYlkadt/n8O69/m4Hr39YMwO3//jQjPu+UY17Y34VzJMBXPrQFU9nsfhjm+lz0D/nR67SsXmnJyJyxotZIR597Xv5HuXjOYCiCy+2nvqYsr99P+Tz373zmIv7/X73GXY8fo3m5mZYG05w+f96JGERFBXgMeEySpHXAfcDvgF9IkvQA8C+yLHfN4xQBRtOIk4WsUKvmhkuasNsXTwHWZFgshgXzd9oHpwpYnNbTDv72hy/yhRs30FRTNivPPxvn4kT7ILWWEhyOzK7dLGVFvNHaS3ePkwLt3JVsytW5sDm9RBQo1qoXzOssXRbSeyRTPn3tWv7t7j18+47dFGhUDAwH0t6HqVarMJvTzyjkYzoRSZLKJEn6pCRJLwAvA28AlwJrADfwZJZP0QHUSpKkiT2fBlgWuz1tbr9mzYSd8GJv2PwwXcWUf7ptK2qViu/ft5+2zvzoMB1RFDrTLDc1mTprKYoC3f352SDT4fIBiHTiPFNWUsiO9dUMe4IMDEfd13O1DzPvIjFJkh4C3k1UvH4J/FmWZf+4+78KuLJ5DlmWbZIkHQA+BNwb+75fluWUUonjMZfpUurnI5h9brx85ZQuAvGKKQ1VBv75o1v5z/v288MHD/L1WzazcplxHmc7M/0uH75AOCsRq62Ml59yjzbLzCfiIiaMHfPP7iNTxWou9mHmYyT2OtAsy/I1siz/73gBA5BlOQLkor3rZ4EvSpJ0Avhi7Pe0ECWlFhaJ6sONj4rLS3X83YfOw6Av4GcPH2ZweGGbb9LpIZaMqgo9Wo2arjx1KPa7vKiAilleyxTMzHyZ2PIuEpNl+QcpHJN1bkSW5ePAhZk+3lSq472XNIkIbIExU1RsMuj40k0b+Y979vGf971FKBTOKL8/F3TYhlEBdZWZi5hGraa2smS0dFW+4RjyYSwtjPaeE8wryfZlzvY+TPGfnyX+8batC+oDT5A6ddZSLtlYg23QO+f5/XTosLmxVhSjK8zOkFFvLR216ucbDmGvXzAk2pdZoFGlnI2KRDKryShETCBIwIG2qcufC22Tero9xJJRby1lyBPE5V7Y6dNEON0BTAYhYguByel6AAW4Y+dRvvGLXdNeANqdXr5z976MnleImECQgIW+Sd3jC9Lv8tFYlRsRA/IyGnO6/ZSXLvzuw0uFHeuq+a/PXcynrluLWhUtswczZzKe29eJPxDK6DmFiAkECVjoDUzHKnVk7yisr8pPEfP6Q/gCYUylC+N/IhjjkZdOTWlUmyyT4QuEeOVQT8adPYSICQQJyDa/P9u0x5yJuYjESooKqCjT5Z2IOWPpz3IhYguOdDIZL+zvwusPcenGmoyeK+/ciQLBXDC5PxlAndWwYMw67X3DlJUUYszRB3i9Jf/MHU531HRTbhAittCYyam4u7V39L2lUkX3KzZUZZZVEJGYQJCEeH7/rn94O++7tIkzPUO0nh2Y72kB0G5z05CDKCxOfVUpPQ4PwdD0TUQXEmORmFgTW2gkymSoVfC+y1aMtqeKi5yiQN+gh7cSmKlSQYiYQJAC77mwAatJzx+ePjHv7dlD4Qjd/SM05GA9LE6D1RAtY5VHm55FOnHhMtmpqNdpiCjR6DlRe6pQWOGp19szei6RThQIUqBAq+HWd7bwoz8e5Ok9HVy9vXHe5tJlHyEcUXIaiS2viQrimZ6hWSuAnGucwwF0hRr0OvExthAZX1ggElH49c5WHnox+RaVwQy3eIhITCBIkY0rzZzXXMnOXWcZGPLN2zza+6LVNTJdQ0iEuawIY0khp7qGcjbmbBO114soLB9Qq1V86rq1XH/xcpI1DMrUZSpETCBIgw+9oxlFUXjg+ZPzNoczvcPodRqsJn3OxlSpVKxYVsbpntREbHdrL9/4xS5u/97zM25knS0G3X5MYj0sb9Co1dxw6Qpuv3YNBZqJUlaoVfPu7Q0ZjStETCBIg8pyPdfsaGTvcRutZ+bH5HG6y8WKmjLUk9tUZ8mKZWX0DXhwe4PTHjd5YX6+SnI5h/3CmZiHXLy+ho9fPbU91ZZmS0bjiWSyQJAm77mwgdda+/jtk8f4zu0XUFxUMGfP7Q+E6bC7uXbH8pyPvSLWeuZMzxAbptl4mmhhPhCK8PCLJ+dsC4KiKDjdAZFOzFNy2Z5KRGICQZoUaDV8+rq1uNwBfv+UjKIoMz8oR5ztHUJRolFTrllebUClgpOd07fjS7aRNV4seS4Y8YUIhSOUl4h04lJHiJhAkAFNNWW895Im3jxm49l9nXP2vKe6o2tWsyFiep2W5dVlHDs3OO1xFYbEwqFWq4jMkaAPe6KCWSbWxJY8QsQEggy5ensj5zVX8sCzbew5bpuT5zzV5cJq0mMonp0P73VNJk53D+HxJS/GumFl5ZTbNGoVkYgyYxSXK4ZGoiI2W+dBkD8IERMIMkStVvHp69exstbIL/98hKf3dEyJRMa7+G7/96ezMj9EFIW2ThfNtcZsp56UdcsriCgKx9sTR2OhcITWMwNUGotGIzJzmY7b3i2hK9DwxtG+WZvbeIY9UfNJmRCxJY8wdggEWaAr0PC1Wzbzq7+08sBzbeyTbVy9vZF1TRXsOW7j7iePj5og7INe7n7yOEBGi9qdNjdub5DVjaac/g3jWVlrpKhQw4GT/WxpmeoWe+lAN/0uH1/9wKYpVccPtPVz5Ixj1uY2ntF0YvHcmWoECxMhYgJBlugKNHzhpg3sOtTDwy+d4scPHaJQqyaiKKP9lOLE21FkImLxtao1syhiWo2aemspuw718OqhHsxlOm68fCU71lXjC4TYuesMUn0565oqpjx2XVMFB072Yxv0YDUVz9ocAYZikViJXojYUkeImECQA9QqFZduWsaO9dUcOuVAbnfyzN6OhMfG3X3jK3mPF4tkHDs3SFVFMRVls9fJeHdrL2e6h4hLb3wPGEQjySFPkC/evBJVgj1q8QixrdM1ByIWoKRIi1YjVkSWOkLEBIIcotWo2dJiYUuLhbdO2JLa0e987Ch7jvURnNT5FhKnGv2BMMfODXL5pmWzN3mie8BCkanR4507j6LRqNjaYmHlssRrcjXmYooKNZzpGeLiDZn1hkqVYU+QMmGvFyCMHQLBrJGssWa9tZTXjvSOClicQCjCfc/IU8bZ3drLN/5nF8FQhDeP9c1qZYxkoqsQrTTe0lCe9LFqlYrl1QbOpFi6KhuGRwIYRCpRgBAxgWDWmNyOwmLS8/Gr1/Avnzg/6WNGfOEJIhUv8eT2Ri3vQ57grJZ4is81GU+/OX27jOU1ZXTY3LPermbIE8AgIjEBIp0oEMwq48vrWCwG7PbhGQVovPEjWYmnTM0hM3Hj5SsnOConkyxSi9NUU0YorNBhc89qS5dhT1DY6wWAiMSmIEnSRyRJOiRJUkiSpC/M93wEi49HXkreUwkmCkUy0ZhJTDIlHj2qk9QWnilSa7BGe5x12t25ntoo4UiEEW8Qg7DXCxAilogDwC3AffM9EcHiZCYBGi8UyUo8zSQm2bBjXTWfvHbtlPW8Qq2aGy9fOe1jK8uL0GrU9Dg8szY/tzeEgqjWIYgiRGwSsiwfkWX5KDC/PegFi5aZBGi8UDTXT90TloqYZMvk9bx4u4yZUpgatZrqCj3d/SOzNrfRjc5iTUyAWBObNczm3LWOz3csltx1IM53LBYDH792HT96YD/hyNRiuRq1Cr2+kApzKW+29rBPtrOi1sjQiB+H00elSc9Hr1rD27bWz/pcr3+bgevf1pz245pqy2nrGJzx/57p66LbGe2qXV9jXDSvrcXyd8wHS07EJEl6C0jWQrRKluVwLp7H4XATSfAhtdSImxkEY+diXUM5t1+zhvuekRnxRV9upXot772kiT3H7fzkwQP89I8HUBRorDLw5Zs3UjrJTr6Qz2lFaSF9Dg9d3U4KCzQJj8nmddHRHS0yHA6GFvR5SBXxHomiVqsyuvhfciImy/KW+Z6DQJCsKeAV59Wxv62f0z0uqkzF7FhXTYE2v7L+NeZiFKB3wENDVe4jjHg6URg7BLAERUwgWMio1Sq2Sha2Spm1al8I1JhLgNkTsSFPEJUKSuewo7Zg4ZJfl3hzgCRJH5IkqRN4P/BvkiR1SpK0dr7nJRDkC5XGaG3HfpdvVsYf9kSrdaiT7QMQLClEJDYJWZbvB+6f73kIBPmKXqelVF+A3emdlfGHPUFhrxeMIiIxgUCQcyzl+lkTsSFPQKyHCUYRIiYQCHKOpbyIfucspRNHAmKPmGAUIWICgSDnWMr1OIZ8hCO5rxkw7Ali0AsRE0QRIiYQCHKOpVxPOKIwmOMaj6FwBI8/hKFEpBMFUYSICQSCnGOJORTtOXYoDnuCAKKCvWAUIWICgSDnWMr1ADk3d4iNzoLJCBETCAQ5x1SmQ61S5VzEhkZFTERigihCxAQCQc7RqNVUlOlw5DqdOBJLJwp3oiCGEDGBQDArVJQVMTCcW2OHSCcKJiNETCAQzAoVBh2Dw7mNxIY8QTRqFcU6UWxIEEW8EnKPBhB13cYhzsUYS+lcNFQZOGcbBhWoVVP/7ozOhQqWLytDo1lc199L6XWRjHHnIHH/niSoFEX0vMoxlwCvzPckBAKBIE+5FHg11YOFiOUeHXA+0APkpMGmQCAQLAE0QA2wB0h5MVWImEAgEAjylsWVWBYIBALBkkKImEAgEAjyFiFiAoFAIMhbhIgJBAKBIG8R+8QEgkWOJEkriTq+3inL8luSJC0DDgE3y7L84rxOTiDIEuFOFAiWAJIkfQr4KrAV+BNwWJblr8/vrASC7BEiJhAsESRJehRoAhTgfFmWc1vYUCCYB8SamECwdLgDWA/8VAiYYLEgIjGBYAkgSVIpcBB4AbgK2CDL8sD8zkogyB4RiQkES4MfA/tkWf4b4HHgl/M8H4EgJwgREwgWOZIkvRd4D/DZ2E1fBbZIkvTh+ZuVQJAbRDl9vtcAACAASURBVDpRIBAIBHmLiMQEAoFAkLcIERMIBAJB3iJETCAQCAR5iyg7lXtEU0yBQCBIn4yaYgoRyz3nA6/M9yQEAoEgT7kUeDXVg4WI5Z4egMHBESIR4fw0m0txONzzPY0FgTgXY4hzMYY4F1HUahUmUwnEPkNTRYhY7gkDRCKKELEY4jyMIc7FGOJcjCHOxQTSWoYRxg6BQCAQ5C1CxAQCQc7Z+dpZdh/pne9pCJYAQsQEAkHOeWZPB68eTmtpIyUUReE3jx3l2LnBnI8tyE/EmphAIMgpXn8ItzeI3enN+djDniC7jvRSWKhhTaMp5+ML8g8RiQkEgpwSF6+BIT/hSCS3Y7uiY9sHcy+QgvxEiJhAIMgpdqcPgIiiMDic296b/bGxbbMQ5QnyEyFiAoEgp4xPI8ZFJ1f0xyIxh8uX8yhPkJ8IERMIBDklnvID6HflWsSi44UjCo6h3EZ5gvxEiJhAIMgp9kEvdZYSVIxFTrmi3+lFo1aNPo9AIERMIBDkFLvTS7W5BFOZLueRmN3lo2lZGSDWxQRRhIgJBEuUA239vLC/K6djRiIK/S4flvIiKsuK6M+h0EQiCg6Xj+ZaIwVatYjEBMAC2ycmSdJZwBf7Avh7WZafkiRpO/ArQA+cBT4iy7It9pg5vU8gWCz89Y1z9A54uOK82pyNOTjsJxxRsJTrcbkDHG/P3aZkp3tsbEu5nr5BT87GFuQvCzESu1mW5c2xr6ckSVIB9wKfl2W5BXgZ+B7AXN8nECwWFEWhwz7CkCeIxxfM2bhxZ6KlXE+lsYjBIT+hcG5chPGxK8uLsJbrc76ZesgT4Jt3vkF733BOxxXMLgtRxCazDfDJshzvL/NL4APzdJ9AsCgYGPLj9YcA6B3InRhMFDE9CjAwlJt1sfj6msUYjcTsTh+Kkrvq72e6h+juH+HwaUfOxhTMPgtRxP4gSdIhSZJ+IUlSOdAAnIvfKctyP6CWJKliHu4TCBYFHfax/lV9A7lLy9mcXtQqFeYyHZXGIiBqxsgFdqcXFVBRVoTVpMcfDDM0EsjJ2AA9juh56LCJ3l75xIJaEwMulWW5Q5IkHfAj4GfAn+Z5ThlhNpfO9xQWDBaLYb6nsGBYKOdi8GC0OK9aBUP+UM7mNewNYa3QU11lRF1QAIA/nPjvTvc53f4wZmMRy2qMNMeE0a+ocjZ3pyeaVu3q98z5/2mhvC7ykQUlYrIsd8S++yVJ+gXwKPBjoDF+jCRJlYAiy/KAJEntc3lfOn+Lw+EWje6IvjntdrHGAAvrXMhnHVQai1CrVJzpdOZsXh19w1QYdNjtw0Qikdj4g9jtExMZmZyLzr5hTLGxddGtYrSddWA1FOZk7me6nAB02910djnRFWpyMu5MLKTXxXyiVqsyuvhfMOlESZJKJEkyxn5WAbcAB4B9gF6SpEtih34WeDD281zfJxAsCjrtI9RZSqmqKKbXkbt0ot3pxVKuB0CjVlNRpsORo3Riv8tLpTE6ttlYhEoFthza7HscHoylhShMTLcKFjYpi5gkSe9PcvvNOZpLFfCiJEmHgCNAC/A5WZYjwG3A/0iS1AZcDvwDwFzfJxAsBoKhML0OD3XWEqoq9PQOenJikIi3YImLGEClsWhCGapMCYUjDA75sZRH19m0GjXmsqKcORSHPQHc3iAXrK4CohGlID9IJ534G+CPCW7/NfBQthORZfk0cF6S+14DNiyE+wSCfKe730NEUaizlOL2BgkEIzjdAUwGXVbjjncmxqks1+fE7ecY8qHAaCQGYDXpc1a1ozdmblnXZOK1Iz20C3NH3jCjiEmStCL2o1qSpCZANe7uFYxtTBYIBHlAZyxVVm8tHW2V0jvgyZmIWSdFYi53gEAwTGFB5mtM8Wr48Ugs/jx7ZXvGY44n7kysMZdQby2lvU+IWL6QSiR2ElCIitepSff1At/O8ZwEAsEs0ml3U6BVYzXp0cWEpXfAk3WnZHsCobHEIifHkI8ac0nmY8dSkuMjMYtJj9sbxOMLUVyUnUet1+GhQBtNUTZUGXhhfxfhSASNesHYBgRJmPE/L8uyGkCSpJdkWb589qckEAhmk06bm2WVJWjUasoNOgq16pzsFbM7vZQUaSkuKhi9zRzbK9bvyk7E+p0+NGrVhGgxHvHZnV4aq7OzqPc4RqgyFaNWq6i3lhIMRegb8LKsMvM5C+aGlC8zhIAJBIuDDvsIdZboh7NapcJqKh5dE8oGu9NL5bhUIoytj2VbCLjf5cVcVoRaPbaaYTUVA7mpZt8z4KHGHB2vsSoqiO02Ye7IB1KOwWPrYf8BbAYmmPllWW7I8bwEAgEQDEVwuf1TxCFThkYCDI0EqLeMvYWrzcU5cePZnV7qqyZGRMbSQrQaVdYtWfpdvtGoLk48bWnLshBwMBTB7vSyfW3UmVhtLkarUdHR52b72qyGFswB6SR87wMiwNeIWtDHfwkEglng0V1n+OZv3sAXCOVkvLipo846TsQqonUIsynUO74Fy3iiJaiKsi491e/0Thm7qFBLWUlh1nvFbIMeFCUqXhC179dWlubUoWh3erlj59Gc/R8FY6SzGroOuDi2j0ogEMwyiqLwxtE+AsEIZ7qHWLM8+/KdnbapIlZlKiaiKNid3ozXreItWKwJIsbKcj2OLPaK+QNhhjzBCaaOOLmoZj/qTKwY+9vrq0o5eLIfRVFQqVTJHpoyu1t72d3ay/oVFexYV531eIIx0onEXibJPi6BQJB72vvco2m4tk5XTsbssLspKymkrHisVFN1RTQC6cuimr0twR6xOJXGolHnYib0u8ZasEwmF3vFemLrgfHzANBgLWXYE8Tpzk2B4RMd0ZJWe4+LtoS5Jp1I7CzwlCRJjxC11o8iy/K3cjkpgUAAe2UbalXUkdfWlRsR67SNUG+ZGG1VxT68szF3JNroHKfSWITbG8QXCFFUmL4V3j6uBctkrOV6dh/pJRgKU6DNbB9ar2MEc5luQq3EhtjaXodtOOv9c6FwhFNdQ6hVKg6fHsDrD6HXLaiytXlNOpFYCbATKADqJ30JBIIcoigKe47bWN1YzoaVZk51ubIuKB2OROh2jExIJQKU6gso1Rdk1SnZHmvBUlE29QM/ngbM1NzRP9oMc6qIWUzRnmXZRHo9Dg/Vk9KodTHjSy42Pbf3ufEHw1yxpZZQOCL6leWYlC8HZFn+xGxORCAQjNFpH8E26OU9FzSgK9Dw4v4uOu3u0QghE2yDXoKhyOgH9HiqsywEbHd6MRt1CTcHx9OA/S5fwueeiX6Xj8ICNWXFBVPui6/B2ZyZ7elSFIWeAQ+XbqiZcHtxkRZLeVFOzB3xVOLV2xvZK9vYe9zGBWuqsh5XECWtmFaSpDXAzUCVLMtfkCRJAnSyLB+aldkJBEuUvcdtqFRwXouFQDAMwMkuV1YiFm/2WG+dKiRVFXqOnEmr29AE7E5fwlQijIvEMly7sjuj1esTGSwsptiG5wwdik53AH8gPLpHbDwNVkNOth6c6HBiNekxGXRsbbHw6uEe/IHwnLV6WeykW8X+ZaAW+GjsZgPww1mYl0CwpNkr25DqyzGWFFJpLKK8tJCTWZo7Ou1u1CpVQgdidUUxLncArz8zC7jd6U3oTAQoKy6gUKvOOJ3ocPlGu0RPxqAvQK/TZGyz73GMAExJJ0LUoWgb9GZ8TgAiikJbp5OWunIAtklWAkGRUswl6ayJfQe4UpblzwLh2G0HgU05n5VAsITpsrvpcXjYttoKgEqlYlVdOW2dzqzG7bSNUG0upkA79W0fd+ZlIgaJWrCMR6VSYTYWZSxi9mlETKVSYSnP3KE4Vvg3QSRWZUABuuwjGY0N0NM/wogvRHO9EYCW+nIMxQXslYVLMVekI2JWoqIF0YLA8e+ifbFAkEP2ynZUwJYWy+htzbVGHEN+BoYyNzB02t2j5aYmE3co9gyk/4E9nTMxjqVcP2qVT4cRXxCvP5Rwj1gcaxYi1uvwoNdpMJZM7Q7dEEu7ZlN+Kr4eJtVHIzG1WsWWFgsHTzlG08SC7EhHxPYxtTrHLcCbuZuOQCDYK9torjNSXjrm9FtVF72SP5mh1d7jC9Hv8iVcD4OoEKjIbK9YKiJmNhaNtlNJh0QtWCZjMenpd3ozcm/2DIxQXVGScL3NZNBRqi+gPYt1sROdLoylhRPOzTbJij8QpjWLNUjBGOmI2JeAf5ck6SWgRJKkp4B/A74yKzMTCJYgPY4RuuwjbI2lEuPUW0spLFBnvOm5qz9q6qhN4g4sLNBgNhZlVM0+UQuWyViMejz+EB5fMM2xp7ZgmUyVqZhwRGFgOH2R7HF4EqYSIZqqzKa3mKIonOhwItWXTxBJqaGckiJtzlKKA0M+9izhTdTpVLE/DqwGfg58E/gtsEGW5bZZmptAsOSIN3ncOi6VCNF6fitqyjI2d3TG1nXqp7G4V1VkVs0+UQuWyVSOa8mSDvHjpxXIuM0+zfU8rz/E4LA/qYgBNFSV0mkfIRxJv9pev8vH4LCf5pipI45Wo+a8FgsHTvYTDGVfxe+3Tx7nf/58hJcOdGU9Vj6SVsc3WZY9siw/KMvyf8my/IAsy6L9qWDJc7LTxR07j+L2phdlJGLfcRsra8uoKJv6od1cV067bTgjt1ynzY1ep024GTlOdawli6Kkl5azO73TphJh4l6xtMZ2eSnWTS+Q4/eKpUN8c3d1RfL9ZQ1WA6FwJKM9dJPXw8azTbLi9Yc5eja7lOLp7iFazwxQqi/gD8+c4HT3UFbj5SPTipgkSX8d9/MrkiS9nOhr9qcpECxM3jjax/fv38/u1l4ee+1sVmP1DXpot7nZJlkT3t9cZ0RR4HRP+h9UHXY39ZbEaz9xqir0+AJhhkbSqxdoS0XEMtwr1u/0JayZOB6TQYdWo0p7r9h0zsQ49VVxc0f61+snOpyUFGlZlsBMs3a5Cb0u+5TiY6+dpaRIy7c+vo3yUh0//9PhtP9/+c5Mkdjvx/18J/CbJF8CQUKcw35eP9qbdcmkhYaiKOx87Sy/erSVFcvK2LbayvNvdWbkwIuzL5ZKTCZiK5YZUUHaKUVFUei0ualNYuqIE29Fkk5KMRJRcLiSb3SOU1KkpahQk0E60ZuwZuJ41OrMbPY9Dk+sKWjy8asritFq1HRksC52osNJc1056gQXDlqNmvOaK9l/IvOUYnvfMAdO9nPltnoqjXo+/74NuL1BfvmXIxmlP/OVaSt2yLJ837if75796QgWE112Nz995DC2QS97j9v59HVrKSzIXZUCRVEIhiI5HTMVQuEId//1OLsO97JjXRUfv2oNQyMBDrT185dXzvDJazPrpLj3uI2mmrIpzR/jFBdpqbWUcjLN/WIOlw9fIDztehhE04kAfYNepAZTSmMPDPsIR5Rp16wgapKoTHOvmKJEe5RtXGme8VhLuT7tNbFexwgWkx6tJvm1vFajptZSkrbN3uX20zfo5bLNy5Ies02y8tqRXg6f7KfenH7T08d3n6OoUMM7ttUB0Fht4GPvkbjzsWM89OIpPvj25rTHzEfSqdjxE0mSLpp020WSJP0o99MSzBXBUJhn9nTwr7/dw+utvTM/IEWOnHHwf+7dRygc4artDew/YecHDxzIyboRgNPt5z/v28+XfvIKf3j6RE5a1KfCiC/ID//3ALsO9/LeS5r4m2vXUqBVYzYW8c6tdbx2pHe0Z1c62J1ezvYOs221ZdrjmuuMnOoeSiuyjZs6Jhf+nUxFWRFajTqt9Z8xZ+LMH8KVRj32NCLVoZEAwVBkWmdinPhesXTW83oGPNRUJE8lxmmIORTTGTvuIm1JsB4WZ12TiaJCDbsOdac8bpwexwh7j9t4x9Y6SsatF160voZ3bKnjqTc7ePNYX9rj5iPpGDs+BOyddNs+4NbcTWfhIElSiyRJuyVJOhH7vqgua8KRCK8c7OYff/069z/XxqDbz693HuWOna1ZldkBeHF/Fz968BDmMj0/+NLlvP9tq/j/bljP2d5h/s89+zKuoRdHbh/k27/dw9neITasMPPigS7+8Ve7+cWfj3Amg/WiVLE5vfyfe/bR1uniU9eu5b2XNE1YY7p6RyNFOi0Pv3Qq7bHjqcStSVKJcVbVGfEFwqMdmlOhI3Zs7QwFctVqFVUmfVrpxLgFPlnJqfHEI7FUxSDegiVZtY7xWEx6/IEww57ULpIiEYW+geT2+vE0VBlwe9PrLSZ3OCksUNM4Ta3LAq2Gzasq2X24J+303+O7z1GgVXPl+VObiHzwHatYVWfkrieOpfU6mYzHF+Kep2X+7wP7eXpPx5xdKKZLOgWAFaaKnibBbYuFXwI/l2X5XkmSPgL8Cnj7XE4goigMuHx09Y/Q3T9C74CHOmsp2yRrxj2OIorC3uM2/vTKGfoGPDTVlHH71WuQGsrZuessO187S1uni09fv45Vtcb0xo4oPPjCSZ7e08HGlWY+c/06LCY9dvsw21ZbMRQX8NOHD/Mf9+zjKx/YlHYxW0VRePKNdh5+6RRVpmK+cctmai2lDA77eXZvBy8e6GLvcRst9eW858IGNq40J1yPyIRTXS5+8vAhIhGFr9+yOWG6rVRfwNXbG3j4pdPI7YMpp+QgusG5scowoxg0xzY9t3WmXgy40+bGUl6UUg+r6opiuh2pV+2wO71o1CpM07ge41SWR4XG7Q0yvVRHma4Fy2TGOxTLElTfmDK2y0sorIyuA05HQ8zcca4v9d5ibR1OVi4zTpuqhOhFy+tH+5DbnaxNsXO3zenl9dY+3rmtbkJz0zhajZrP3bCef/3tHn72yGG+9bFt07o7E3Hs7AB3PXGMgWE/VaZiHniujQeea6PWUsLmVZVsbq6kqaYsZ++vbEhHxF4hutn572RZjkiSpAa+Hbt9USFJkhXYAlwZu+l+4GeSJFlkOXbJPAMH2vpRqaLrGHGLcEmRNuGLWlEUnO4AXXY3Xf0j0S/7CN2OEfyBsdI0JUVaXjnUw/3PtrGqzsg2yco2yZLQjp3oOQ6fHuCRl0/R3uemtrKEL964gc3NlaPRxA2XrmDt8gru2HmU7937FtdfspxrdyxHrZ75heoPhPn1zlb2t/Xzjq113PKOVVPackgNJv7xI1v47z8e5Ht/eIvPv28D65pSe+N6fEF+8/gx9rf1s221lU9ctXr0Q9lk0PH+K1Zx7UXLeflgN8/s7eAnDx2ixlzMey5oYPu66oT1AlNlz3Ebdz52FFOpjr99/8aEBXTjvHNbPc/t6+ShF0/xT7dtTam1vcPl43T3EDddvmLGY81lRdEmmZ1O3rG1LqX5R8tNpdYCpaqimAMn+wlHIgnbqkzG7vRiLitK6djxe8Vm/kvTi8Ti5gzboCeli68xZ+LM7Vvi566jb5jNqypnPN7jC9Jhc3P9JU0zHrthRQVFhRr2yvaURezJ18+hVsO7L2hIekx5qY7PvW89379vP3fsPMoXb96YkuD4g2EefvEUz+7rpKqimH/6yFZW1hqxOb0caOvnQJudJ19v5/Hd5zCWFLJpVSXnNVeyptE07dq0oih4YvvynG4/zuEArhE/m5stM2YIZiIdEftb4DGgR5Kkc0AD0ANcl9UMFib1QJcsy2EAWZbDkiR1x25PScTue/ZEwoXmwgINpXotJfpCSvUFKIpCR98wI76xFF65QUdDlYF3raqkocpAY3UZ9dUGSvUFdPQN89qhbnYd6h69OlrdaOLiTcu4aOMyrKapV5atpx38/omjHD0zQFVFMV+9dQuXnVeHJoE4WSwGNq2p5n8ePsifXznDiU4XX7t1K9Zp1g4cLi//9959nO5y8ekbNnDdpRM/oiwWw4Sff/jlcr59x+v86I8H+dIHz+Pt26bvq3q6y8X37nkL26CHT713PddduiKpOHykzsQt71nDqwe6eOTFk/z2yeP8+dUzXHfpCq7asZzSBFeuyVAUhYdfOMndjx9lzfIK/vkTF2AsnflK/CNXreFnfzzIqb4RdkzqUzX+XMR57VjUZv2uHU1YUhCbdSvMHD83mHCsyQSCYfoGPFy2pS6l45sbTTzx+jkUjRZLCh8ug+4Ay6ylKY3dEoymzAKxbOJMj3H7QpQbdNQtS76uFKfcVIxKBSOBSEpzGW6Nrhetb7FiSOE1UVNZQp/Ll9LYe4/1oQAXbKhJ6fhta6o40NbPl2/dmvA9OZ5+p5ddh3u48sJGWlZML6gWi4FPjQT55Z8O8/yBHj70Lmna4+VzA/z3/W/RZR/h2kua+Ng1a0c7cVssBtY1W/kwMOwJsO9YH6+39rLnuI2XD3ajK9SwRbKyqdmCPxDGMeRlwOVjYCj25fIRSODCrKwoYfOa6ulP0Ayk0xSzU5KkLcCFQB3QAbwpy/LS8XKmwdc/dB7OYT8eX7TUjscfYsQXwusLMRL73eMLgaJwwZoqllWWUGcpYVllScI3ldftw+v2UaSGt29exts3L6N3wMPe4zb2yjZ+82grv3m0laaaMs5fHY3QRnwhHnn5NIdPOzCWFnLbu1q4dNMytBo1A47pc+Ufe1cLLbVl3PP0Cb7wgxf46LslLlw7tZFfe98wP37oEB5/iC/etJFNqyqx28ecXBaLYcLvo+fng5v52SOH+O/736K928nV2xsTCtMrB7u595kTlOoL+Ptbt7Cqzkh//8x5/nUN5ay9bStHzw3y1zfa+f0Tx3jgaRlLuR5DcQGG4kIMxQWUxb4bJn0vKtTyh2dkXj7YwwVrrHzymjUEvAHs3pnXRTY1maiuKOa3O4/QZC0ejVKSnYsX93VQby2lACXh/ZOpt5Tw6sFu5FP2GaPwc73DRBQwlxSmNHZxQXSuR0/a0CozRx09/SNskywpja0ORz8qTncMcsmm2hkf09k3jNmgS2lsgAqDjrNdzpSOP9k+QFlxAb4RP74R/4zH15qLOdme2thvHulGo1ZRUVyQ0vEXb1rGqwe72b2/Y8YU9H3PnEBR4IqNNSmNfX5LJYfWV3P/U8exlhWyceXU/2koHOHRXWd4fPc5TAYdX79lM2uXVzDs8pLsGdY1lLOuoZyPXtmC3DHI/rZ+DrT1s/twDwCFBWpMpTpMBh3LqwxsXllJeWkh5QYd5aW66PeSQgoLNKN/h1qtwmxOv2lqWk0xY4K1O+1nyT86gFpJkjSxKEwDLIvdnhLWcj2VKaT5sqG6ophrL1rOtRctp28wLmh2HnzhJA++cBKIpiDff8VK3r6lDl0aVnSVSsVF62tYVWvk1zuP8qtHWzly2sGtV7aMpvEOnuznl4+2UqzT8o8f3pLWGldxkZavfGAzdz1xjIdfOs3gsJ9b39kymroMBMPc+8wJXj3Uw5pGE5+5fl1Kax2T/4Z1yytYt7yCDpubVw52MzDsZ8gToN3mxu0JTIiAE3HtRcu54dKmtHL/GrWamy5fwc//dIRdh3u5bFNym/XgsJ+TnS7ed+nMqac449fFLlw7/Wss3ghzJmdinHhLlt4BLxtXTn+sxzd9C5bJFBdpKSnSplwI2O70sjKNddl09or1ODwJe4glo77KwF7ZjtcfmnFtsa3DxfIaQ8rvt62rqyjUqtl73D6tiLlGArx0sJsd66pTWieE6Hvgo++W6LS5+fWjR/nWx7dNyNZ02tzc+dhR2m1uLt5QzYfe0UJxUeqyUKBVs77JzPomMx+5sgXHkI+SogKKCjUppdJzwbSzlSTpmCzLa2I/d5Ck7Yosy8mTs3mILMs2SZIOEHVk3hv7vj/V9bD5oMpUzDU7lnPNjuXYnF72yTYUBd62uTatF+VkrKZi/uHDW3h011ke3z1m+jjd7eL+59posBr40s0bMzKaFGjVfOq6tZgMOv76RjtOd4BPX7cWp9vPL/50hHabOyoilzSltC43HfXWUm69smXK7aFwBLc3yLAnyLAnwJAnEPs5SFO1gfNapre8J2NLi4UVy8r4y6tnuHBtVdIPtLdOxDY4r07F6jD2t+gKNJzsdCWMjsfTaXdTqFWn5B6EqDmlpEibUiHg+MbuVEUMSLmvWDgSYXDYn9J6WByrqZj9bam9RXscHrZKqf9v421ZOmzuaW3zgWCYMz1DvCuBazAZep2WDSvM7D1h40NXNie9YHr6zXZC4QjX7GhMeWyILmF8/sYNfOd3UaPHP9+2jQKtmr++2c6fXzlNsU7LF2/awHnNmb3W40T3Aqa/3y1bZvp0+9S4nz8ymxNZgHwWuFuSpG8Bg4x1s17wWMv1XHVhei/06dBq1Nx42QrWN1Vwx85W/uP3e1GAzasq+cz167Jqs65WqfjAFaswlep44Lk2vnvvW9icXtQq+Nubo+nJ2USrUUfTGymsdaWDSqXi/W9byX/et5/n9nVy9fbE/4+9x23UVpakZDCIo1GrWbGsjLaumTc9d9jcLKssSfkiQKVSpVwIOJUWLJOxGPUpuR8Hh/2xTdSpj2016Rn2BGeMloY9AdzeYEp7xOLEswwzidjp7iHCEWXaYxKxVbKw74SdU12uKQWDAdzeIM/v7+LCNVWjvd/SwVKu5zPXr+O/HzzIr3e2MuwJcrLLxVbJwm3vlhK6HPOFmUTsB8D22M9vk2X5X2d5PguGWNX+C+d7HguJlvpy/vX2C3jwhZOUlehyEiHFufL8ekwGHb/eeZRaSwmfv2F9yimThYrUYGLjSjNP7D7HZZuWMfk61+X2c6LDyXUXL0977OY6IztfOzvjB3aX3c3GNC8EqkzFHG8fnPE4WwYiZjYWcei0Y8a9YvGUY7LqJYmIR5t2p3fa1HZcoNNJJ5aXFqbUW+xEpxMVYynfVNm0qhKtRsXe4/aEIvbs3g78gXDaUdh41q8w877LVvDIy9Ho61PXrWX72qo5S/vNFjOJWIskSUWyLPuArwFLRsQEiSkuKuDjV62ZlbG3rbbSUl9OcZKtCPnITZev5Nt3vckTr5/j8w0TLdRvnbCjkF4qMc6qeDHg7qGk2xRcIwGGPMEZy01NptpcYt9nJgAAFuxJREFUzO7WXvyB8LRRtt3pi7VgST1dbSnXEwxFcA5Pb6aIV/awpCFi41uyTCdiqRT+nYxKpaKhqnTGQsAnOpzUWUvT3pel12lZ32Rmr2zjg+9YNSGl6PGFeHZvJ1tbLEn7waXK1TsaqSwvoqWuPKWtOfnATK++vwAnJEk6C+iTVayXZfmyHM9LsERJ17yx0Km3lrJ9XTXP7u3kA1eunnDfXtlOdUVxRvtkVi4zolJBW6czqYh1pmnqiBM3d/QNeqYVg1RasEwmvsbVN+jBXJz8g77f6UOlIq0P2vheMfsM5o5ehydaKizND/EGq4Fn93UQCkcSXmSFwhFOdQ1xyaRtFamyVYr2GDvTM8TKZWOR3Av7O/H4Q1x70fKMxh2PWqVi+9rsLO0LjWkvd2VZ/gTRslK/BkKIKvYCQdpEnYcK9z99fPS2IU+A4+2DbFttzSido9dpqbOUcrIreUX7UWdiglYg01EVE4O+GQrqZiViM9Rn7Hd5qTDo0orI9TothuKCGefd4xihylScdiq8oaqUUFhJWluyvc+NPximuT69VGKczc2VaNQq9h0fM6f4A2GeejNaAaexOr0KN0uFmdyJ/yXL8jeAVyVJKhaV7AWC9Kks13PFeXU8t6edyzbWUFtZwv4TdhQFtqXhkJvMqjojrx3pTVpdo8vuxlhamNJm3vFUxSzYvdMYMOItWM5PMxUad6/ZBj2snebD3u7yZeR0s5brZ4zEegY809Y0TEZ97DHttuGE0W28CWa6po44JUUFrF1ewV7ZxvuvWIlKpeKlA124vcGcRGGLlZkucz497ucfzOZEBILFzLUXNaIr1PJIrDjwXtmO1aSnPs1U33iaa434A2E6bYnFJtoIM/3xdYUaKsp09A4kF4OxFizpCY2uUBONlmZwP/Y7vTM2w0yExTR9S5ZgKILd6U1rPSxOdYWeAq2a9iS9xU50OLGa9Fk5XbdJFvpdPs71DRMMhXnyzXbWNJrSrmO6lJhpTeygJEkPAUcBnSRJ30l0kCzL38r5zASCRYShuJCb3r6Ke588zoG2fo6dHeQ9FzZk5QyLu9hOdrmmpJrCkQjd/SOs3ZZaPb7JVJmK6RtMLjSjLVjSMF7EqTTqpxWxYCiM0x2YsRlmIqzlet442kcwFElYL9M26EFRSKnw72Q0ajV1lpLRNO14IopCW6cz432Fcc5rsXD3X2X2HrdzpmwIlzvAp69bl9WYi52ZIrGbgQNADaAiWjsw0ZdAIJiB9166EmNJIb96tJWIoszYO2wmzMaxYsCT6R2IVmlPdz0sTnVFMb0OT1IrfCZ7xOJUGoumFTHHUNS5mEkkZjXpURSSdtgedSZWZHZe6q0G2vuGp5yX7v4RRnwhWhLY49OhVF/AmsZy9hzv44nXz7Gq1sjqhuzGXOzM1NnZBvw7gCRJ2pjRQyAQZECRTsv1lzRxz1MylcaijNZlJtNcZxxtwDieLnvc1JFZurKqohiPP8SwN5hwI2w6LVgmU1lexP42OxFFSVidYrQFS0aRWPHo/BJtIO+J7xHLYMMwRM0dLx/sZnDYP8E52RZfD8uB4GxdbeX3f5UBuO3dq/N+H9dsk7L1R5blT0iSZJYk6TZJkr4BIEnSMkmSUusHIRAIuHRjtB7lFVtqc/LhtKrWyOCwH8ekUk4dNjcatSqtSiDjqa6IORSTREzptGCZTKVRTyisJN0rlk4LlslYTGN7xRLR6xjBXKbLuMpMgzVm7pi0Lnai00V5aWFG6dXJbGm2oFJBY5WBDSsySwcvJVJ+BUqSdDkgAx8G4mtgzcD/zMK8BIJFiVaj5p9u25qzsmDxdbHJJag6bW6qzcUZ91EbKwScXMTigpEulnF9xRLR7/Si1agoz6AeZ1lxAboCTdJCwOkW/p1MraUEFVGHYhxFUTjR4aSlvjwnFyZlJYX8zbVruf2aNSIKS4F0XuE/Aj4oy/J7iO4ZA3gDuCDnsxIIBClRZy0ZLQY8ns4MnYlxzMYiNGoVfUkcinanL6P1sPjYkHzdyu7yYS4ryqhrsEqlwprEoagoCj0DnrRqJk5Gr9NiNeknRGL9Lh+Dw/6MrfWJ2LGuOivn6lIiHRFbLsvyc7Gf46uaAdJs5yIQCHKHRq1mZW3ZBBHz+II4hvzUZmjqiI9rNekTRmJjLVgyS52NdnhO0pIlaq/PvG5msr1iTncAfyCckb1+PPVVhgk1FLPdHybIjnRE7KgkSe+edNs7gcM5nI9AIEiTVbVGOuxuvP5ogqTTHt03lu2VfJWpOOGa2KgzMcO2GwXa6D60pOlEly+rtSWLSY/d6SMyyUHYE9u8nU06EaCxqpR+lw+PLwhERaykSMuyDMqHCbInHRH7GvAHSZLuJlpH8VfA74BvzMbEBAJBajTXlaMocKo7Go11ZulMjFNtLqZv0EskMlEMsrHXx6mqKEmYTvT6o1FetpFYKDy1yHAmhX8TUW8da8sCURFrrivPKP0pyJ503ImvA5uAVuAu4AxwgSzLe2ZpbgKBIAVWLCtDpWI0pdhpc1NSpM2oUel4qiuKCYUjDAxNjJjsGTTDnIzVVJwwEnNk4UyMY0lS+7HX4UGv02DMssh0Q1X04qDd5sbl9tM36BWpxHkkLeuSLMtdRMtP/TvwfVmWO2dlVgKBIGX0Oi31ltLR/WIddje1ltKsnW3xQsCT18XsTh+l+oKsOoZXmYsZGPITjkQmjp0DgawqT1zNvmdghOqKkqzPi7GkkLLiAjr63JyInXMhYvNHOhb7MkmSfg94gU7AK0nS3ZIkiaJeAsE8s6rOyOnuIULhCF32kayciXGS2eyj1euz2w9lNRUTURQGhyam/DJphjmZirKos3KyQ7HH4ck6lQhRB2R9lYF22zAnOpwUFqhHozPB3JNOJPb/2rv34LjK847j313dZUkry7r4foP4gYJThoSQUie9DAQSICXNDAy4IWEmTQOZNG2TNglJCpOElskwkBjSoZOSQAmhwJTSDilJbzBcyqUkoYXUPFBwBBhfJFmSbSHZuvWP9xx5LRSk3T3S2bV+nxnNSueszj67I+2z7znv+zzbgCXAZqAx73bbPMQlIgU4fnWOQ6PjPPNiLyOHx1ndWfokg5YltTTUVb1pmn0xLVimixNkz+CbT1XW1VTR3FBYU8l82WyG9lz9UWvFhg+N0X/gUCJJDGBtZxM7e4Z4vruf41fljpkmrpWokPMB5wAb3T3+WPaCmV0GvJR8WCJSiLhm34M/2wkU3ghzJplMhq6ljezOKwQ8PjFRVAuW6TqjJBYmdyyd2t47MEJ7a33Jp/xCNfsjce+eKjeVzAzCNV1NjE9MsrN3qOTXQkpTyMeHEWB6xdJ24K37jIvIvGtrqaetpY7t3f0ARXWLnsnytqOn2ffvP1RUC5bp2lsbyGTevFasd3C46Kn7+bpaG+kZGJ4q1Ls7oZmJsbj8FOh6WNoKGYn9DfCvZnY90A2sA/4Y+M58BCYihTl+VY6n9u+ls7WB+tpkahB0tTXy5P/u4fDoOLU1VXlrxEq7JlZTnWVp89FrxSYnJ+kZHOGEtUvf4jfnpmNpA8OHxjk4PEpzYy279g2Rjap5JGF5WyO11VnGJybZuLIlkWNKcQr5S78G2EmonbgSeJ0wQ/GW+QhMRArzttWtPLV9byKnEmPL2xqZBPYODLO6o2nqGlaxdRPztecajlordnB4lEOHx0taIxbrjI6xd2A4JLG+N+hY2pDYtatsNsP65c1kMhlqa4orJizJKCSJfQv4O3c/M95gZmeY2Tfd/Y9KCcLMbiVU/+iNNt3j7tdE+7qA24H1hJmRn3D3J9PYJ1LO4u6/xfYQm0k8AWPPvjdCEotasLQ1l16tvT1XP3X6E44UBE6iEnycZHv6hzluZY7dfaXVTJzJ5RecnOjxpDiFfCy5GHh62rafAJckFMu17n5K9HVN3va/BB52903ApwhVQzIp7RMpW2u6mvjQezawZfOKxI7ZOW2tWM/AMMty9WSzpf9LtOfqGThwiNGxsFYsTmLJjMTqyRBasoxPTLCnP5np9flyTXXkmkpbUC6lKySJTQLTx81VBR6jGBcCNwO4+6OECSbvTGmfSNnKZjKc/+sbEkkCsYa6anJNtVNJbG9/6dPrY+25BiaBfQdC8jrSDLP0kVhNdRWtzXXsHRimd3CEsfFJliecxKQ8FJKAHgG+ZmZZgOj26mh7Ev7EzJ41s/vM7MToMZYBGXfvzbvfK8Cahd6X0HMUqTgr2hqn1oolsUYsFi+Yjmco9gyOsKS+moa6ZCaldLY2sHdgOK9mogr0HosK+Wv5DHA/sMvMuoG1wC7g/Nl+0cx+Gt1/Jl3Al4Bd7j5hZpcCPzKzjQXEVnaWLdMK/lhHR/Psd1okKvG1WLcyx+PP7qKhqZ6hkTE2rMol8jw2bWgH4NDEJB0dzex/Y5QV7UsSe43Wrmjh6e17ODAyDsDJmzppbiytbuJ8qcS/i3Ix5yTm7q+Z2amEJphrgFeBp9x94q1/E9z91FnusjPvvn9rZjcAq92928wws/a80dFa4FV371vIfbM9x+n6+g6+qfr3YtTR0UxPz4HZ77gIVOprkWuoYf/QYX7y3OsANNZkS34eHR3NTIyOUpXNsOO1AXp6DrCz5yBrOpYk9ho111fTf+AQP3+ph5bGGkaGDjEyVH7LWiv17yJp2WymqA//hRYAnnD3J9z9nuh21gQ2F2a2Ku/7s4FxjiS2e4BPRvu2AA2ECSVp7BNZdOIZis+9vA8orThvvqpsWCvWMzDMxOQkfYOlNcOcLp6U8vMd+0ruISblq1y6Mt8WTW2fAPYDH3T3sWjfF4Dvm9lHCVPeP5KXPBd6n8iiE0+IeHZHHxAmZCSlo7WBvsERBg8eZmx8MpHp9bE4iQ2NjCU+M1HKR1kksfy1ZzPs201YQ5b6PpHFqD1XTzaTYWfPUMktWGY69n+/1DdVCSTRkVjesZJeIyblQ6WXReQtVVdlp2YSltqCZbr2XD37hw6zq29o6uekNNbXsCRKuDqdeOxSEhORWXVFI5mkrofF4pGXvzIQfk4wiUHoWwbJFf6V8qMkJiKzWj5fSSxKWtu7+2ltqqWmOtk6hJ1RvcRlLckmRykfZXFNTETK2/wlsXC8waHDU7Ufk3TOu9ayeWNbImWypDwpiYnIrNYtD4tx1yRYIR8g11RLdVWWsfEJ2hO+3gYh7jh2OTbpdKKIzGrDihauu+IMNqxItndWNpNhWXRKMcmp+7J4KImJyJy0zdN1pfi6WJJrxGTxUBITkVTFySvJNWKyeCiJiUiq4uSlkZgUQxM7RCRVWzavoLG+euramEghlMREJFUtS2r5zVNWzX5HkRnodKKIiFQsjcSSVwVocWUevRZH6LU4Qq/FEXotjnoNCirbkpmcVOPGhG0BHkk7CBGRCvUe4NG53llJLHl1wGnALkJzTxERmV0VsAL4L2DOLbiVxEREpGJpYoeIiFQsJTEREalYSmIiIlKxlMRERKRiKYmJiEjFUhITEZGKpSQmIiIVS2WnEmRmm4DbgGVAH3Cpu7+YblQLz8yWAbcDxxEWLf4f8Afu3pNqYCkzs6uAq4HN7v5cyuGkwszqgRuAM4ER4HF3/0S6UaXDzM4DvgZkCAOKq9393nSjWhhmdh3wYWA9ef8PxbyHaiSWrJuBb7v7JuDbwF+nHE9aJoFvuLu5+9uBl4BrU44pVWZ2KvBu4JW0Y0nZNwjJa5O7bwa+knI8qTCzDOGD3kfc/RTg94DbzGyxvCffB7wX6J62veD30MXygs07M+sETgXujDbdCZxqZh3pRZUOd9/n7g/lbXoCWJdSOKkzszrCP+QVhAS/KJlZE3Ap8BV3nwRw9z3pRpWqCSAXfd8K7HL3iRTjWTDu/qi7v5q/rdj3UCWx5KwBdrr7OEB0+3q0fdGKPlleDvxT2rGk6KvA9919R9qBpOw4wimiq8zsaTN7yMy2pB1UGqIkfiHwj2bWTRiZfDTdqFJX1HuokpjMtxuBg8BNaQeSBjP7NUJB6L9KO5YyUA1sBH7m7u8EPg/ca2Yt6Ya18MysGvgi8Dvuvg44H7grGq1KAZTEkvMqsMrMqgCi25XR9kUpunj7NuCixXKaZAa/AZwA7DCzXwCrgR+b2fvSDCol3cAY0ekid38S6AU2pRlUSk4BVrr7YwDR7RBwYqpRpauo91AlsYS4+17gGeDiaNPFhE+ci3JGnpldA7wDuMDd59xW4Vjj7te6+0p3X+/u64HXgLPd/V9SDm3BuXsv8CBwFkzNROskzF5dbF4DVpuZAZjZicBywiSoRanY91C1YkmQmZ1AmB66FOgnTA/1dKNaeGZ2EvAc8AIwHG3e4e4fSi+q8hCNxs5bxFPsNwLfJUyhHgW+5O4PpBtVOsxsK/AFwgQPgKvc/b4UQ1owZrYN+F1C4u4F+tz9pGLeQ5XERESkYul0ooiIVCwlMRERqVhKYiIiUrGUxEREpGIpiYmISMVSEhNJkJn9wszOTPiYW82s4HVlUVmnjycZyxwes6hYRYqlViwiZc7d7wDuSDuO6cxsPbADqHH3MSjfWOXYpZGYiIhULI3ERJJ3WlSRYAWhOvnl7j5iZksJPaROJ/zvPQZ80t1fAzCzjwF/DnQQqhh82d3viLZ/3N23RH2orge2AnWEeoSXzFYBJOomcCXw+0AD8CPg0+4+GO3fQuj19SvAAUK7lFvN7Fzg64QK9IPALe5+dXTYh6Pbgah60lmAxbFGxz0D+BahPuILwGfc/T+jfQ8BjwC/DbwdeDx6Lr1ze5lFNBITmQ9bgbMJb/ybgC9H27PA9wi91dYSSnLdBGBmS4BtwPvdvRk4g1BHbrr3EZoJbiL0oLqI0N5kNh+Lvn6LUEm+Ke+x1wIPEDoOdBCK08aPPUToAdYKnAtcbmYXRPveG922unuTuz+e/4Bm1gb8MHpeywjJ94dR5+/YJcBlhBqKtcDn5vBcRKZoJCaSvJvihn9RIeQbCaOqPuDv4ztF+x7M+70J4GQze8XddwG7Zjj2KNBMqIz/lLtvn2NMW4Hr3f3l6LG/CDxnZpdF+/7N3eNmhH3RF9Oam/6Pmd1JqMw/lxp/5wIvuvvt0c93mtkfEtqO3Bpt+567vxDFdDfwwTk+HxFASUxkPuS3jugmtJPAzBqBG4BzCAVOAZrNrMrdh8zsIsJI5BYzewz4rLs/n39gd/8PM7uJ0Cl6rZn9A/A5d98/S0wrOboVfDfh/7+L0HRwxurpZnY6cC1wMmGkVAfcM8tj/bLHjB93Vd7Pu/O+f4MwQhSZM51OFElefifatYTutACfJVwzOt3dWzhyOi4D4O4/dvezCNfSnge+M9PB3X2bu78DOIlwWvFP5xDT64TTmPlxjQF7CEn3uF/yez8gdOVe4+454OY4XmC26uHTHzN+3J1ziFdkTjQSE0nep8zsfsLI4krgrmh7M+E62EB0veiq+BfMrIsw4ePfo/scBManH9jMTiN8+Pwp4XrVyEz3m8GdwOfN7AGgB/gL4C53HzOzO4ArzexC4F4gR0haz0Qx74smpryLcA0rXgfWQzgFupEwaWO6fwZuNLNLgLuBDxMmjtw/h3hF5kQjMZHk/YDwRv9y9PX1aPs3CTMDe4EnCDMEY1nCSO11YB/hutMVMxy7hTBC6yecmusDrptDTN8lzIx8mLC2awT4NIC7vwJ8IHr8fYRJHb8a/d4VwFfN7ABh5uTd8QHd/Q3gGuAxMxsws3fnP2B0DfC86Lh9wJ8Reqlp9qEkRv3ERESkYmkkJiIiFUtJTEREKpaSmIiIVCwlMRERqVhKYiIiUrGUxEREpGIpiYmISMVSEhMRkYqlJCYiIhXr/wFrnQ7/mXjvfwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def basis_plot(model, title=None):\n",
    "    fig, ax = plt.subplots(2, sharex=True)\n",
    "    model.fit(x[:, np.newaxis], y)\n",
    "    ax[0].scatter(x, y)\n",
    "    ax[0].plot(xfit, model.predict(xfit[:, np.newaxis]))\n",
    "    ax[0].set(xlabel='x', ylabel='y', ylim=(-1.5, 1.5))\n",
    "    \n",
    "    if title:\n",
    "        ax[0].set_title(title)\n",
    "\n",
    "    ax[1].plot(model.steps[0][1].centers_,\n",
    "               model.steps[1][1].coef_)\n",
    "    ax[1].set(xlabel='basis location',\n",
    "              ylabel='coefficient',\n",
    "              xlim=(0, 10))\n",
    "    \n",
    "model = make_pipeline(GaussianFeatures(30), LinearRegression())\n",
    "basis_plot(model)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The lower panel of this figure shows the amplitude of the basis function at each location.\n",
    "This is typical over-fitting behavior when basis functions overlap: the coefficients of adjacent basis functions blow up and cancel each other out.\n",
    "We know that such behavior is problematic, and it would be nice if we could limit such spikes expliticly in the model by penalizing large values of the model parameters.\n",
    "Such a penalty is known as *regularization*, and comes in several forms.\n",
    "\n",
    "下面的图展示了基本函数在每个位置的振幅。这是当使用基本函数叠加的典型过拟合情况：邻近的基本函数的系数互相叠加到波峰和波谷。这种情形是错误的，如果我们能在模型中限制这样的尖刺能解决这个问题，通过在模型参数的大数值进行惩罚可以实现这个目标。这样的惩罚被成为*正则化*，它有几种形式。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ridge regression ($L_2$ Regularization)\n",
    "\n",
    "### 岭回归（$L_2$正则化）\n",
    "\n",
    "> Perhaps the most common form of regularization is known as *ridge regression* or $L_2$ *regularization*, sometimes also called *Tikhonov regularization*.\n",
    "This proceeds by penalizing the sum of squares (2-norms) of the model coefficients; in this case, the penalty on the model fit would be \n",
    "$$\n",
    "P = \\alpha\\sum_{n=1}^N \\theta_n^2\n",
    "$$\n",
    "where $\\alpha$ is a free parameter that controls the strength of the penalty.\n",
    "This type of penalized model is built into Scikit-Learn with the ``Ridge`` estimator:\n",
    "\n",
    "最常用的正则化方式被称为*岭回归*或$L_2$*正则化*，有的时候也被叫做*Tikhonov正则化*。这个过程通过对模型系数的平方和（2-范数）进行乘法；在这个例子中，模型的乘法是\n",
    "$$\n",
    "P = \\alpha\\sum_{n=1}^N \\theta_n^2\n",
    "$$\n",
    "其中$\\alpha$是控制乘法力度的参数。这类的乘法模型內建在Scikit-Learn中`Ridge`评估器中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import Ridge\n",
    "model = make_pipeline(GaussianFeatures(30), Ridge(alpha=0.1))\n",
    "basis_plot(model, title='Ridge Regression')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> The $\\alpha$ parameter is essentially a knob controlling the complexity of the resulting model.\n",
    "In the limit $\\alpha \\to 0$, we recover the standard linear regression result; in the limit $\\alpha \\to \\infty$, all model responses will be suppressed.\n",
    "One advantage of ridge regression in particular is that it can be computed very efficiently—at hardly more computational cost than the original linear regression model.\n",
    "\n",
    "$\\alpha$参数是用来控制模型复杂度的关键开关。极限情况$\\alpha \\to 0$时，恢复到标准线性回归结果；极限情况$\\alpha \\to \\infty$时，所有模型的响应都会被压缩。岭回归的一大优点是它能非常有效的计算，基本没有产生比原始线性回归模型更大的计算消耗。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lasso regression ($L_1$ regularization)\n",
    "\n",
    "### Lasso算法回归（$L_1$正则化）\n",
    "\n",
    "> Another very common type of regularization is known as lasso, and involves penalizing the sum of absolute values (1-norms) of regression coefficients:\n",
    "$$\n",
    "P = \\alpha\\sum_{n=1}^N |\\theta_n|\n",
    "$$\n",
    "Though this is conceptually very similar to ridge regression, the results can differ surprisingly: for example, due to geometric reasons lasso regression tends to favor *sparse models* where possible: that is, it preferentially sets model coefficients to exactly zero.\n",
    "\n",
    "另一个常用的正则化类型被称为lasso，通过惩罚回归系数绝对值和（1-范数）来实现：\n",
    "$$\n",
    "P = \\alpha\\sum_{n=1}^N |\\theta_n|\n",
    "$$\n",
    "虽然这在概念上非常类似岭回归，但是结果却大不相同：例如因为几何原因lasso回归更适合*稀疏模型*，即它倾向于将模型系数设置为0。\n",
    "\n",
    "> We can see this behavior in duplicating the ridge regression figure, but using L1-normalized coefficients:\n",
    "\n",
    "我们可以从下面的图中看到这个特点，这里将岭回归改成了使用L1正则化系数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wangy/anaconda3/lib/python3.7/site-packages/sklearn/linear_model/coordinate_descent.py:475: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations. Duality gap: 0.0021358158704868346, tolerance: 0.002065280097246271\n",
      "  positive)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.linear_model import Lasso\n",
    "model = make_pipeline(GaussianFeatures(30), Lasso(alpha=0.001))\n",
    "basis_plot(model, title='Lasso Regression')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With the lasso regression penalty, the majority of the coefficients are exactly zero, with the functional behavior being modeled by a small subset of the available basis functions.\n",
    "As with ridge regularization, the $\\alpha$ parameter tunes the strength of the penalty, and should be determined via, for example, cross-validation (refer back to [Hyperparameters and Model Validation](05.03-Hyperparameters-and-Model-Validation.ipynb) for a discussion of this).\n",
    "\n",
    "使用了lasso回归惩罚，大部分的系数都变成了0，也就是只有小部分的基本函数在模型中产生了作用。就像岭回归正则化，$\\alpha$参数调整惩罚的强度，这个参数应该通过比方说交叉验证（参见[超参数和模型验证](05.03-Hyperparameters-and-Model-Validation.ipynb)中的讨论）来确定。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Predicting Bicycle Traffic\n",
    "\n",
    "## 例子：预测自行车流量"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "> As an example, let's take a look at whether we can predict the number of bicycle trips across Seattle's Fremont Bridge based on weather, season, and other factors.\n",
    "We have seen this data already in [Working With Time Series](03.11-Working-with-Time-Series.ipynb).\n",
    "\n",
    "我们来看一个例子，试图从天气、季节和其他因素中对西雅图费利蒙大桥的自行车交通流量数据进行预测。我们已经在[在时间序列上操作](03.11-Working-with-Time-Series.ipynb)一节中使用过这个数据。\n",
    "\n",
    "> In this section, we will join the bike data with another dataset, and try to determine the extent to which weather and seasonal factors—temperature, precipitation, and daylight hours—affect the volume of bicycle traffic through this corridor.\n",
    "Fortunately, the NOAA makes available their daily [weather station data](http://www.ncdc.noaa.gov/cdo-web/search?datasetid=GHCND) (I used station ID USW00024233) and we can easily use Pandas to join the two data sources.\n",
    "We will perform a simple linear regression to relate weather and other information to bicycle counts, in order to estimate how a change in any one of these parameters affects the number of riders on a given day.\n",
    "\n",
    "本节中，我们会将自行车数据与另外一个数据集联合起来，然后从中找到哪些天气和季节因素，比方说温度、降雨和日照时间，会影响到这条交通要道自行车流量数据。幸运的是美国国家海洋和大气管理局NOAA公开了每天[气象站数据](http://www.ncdc.noaa.gov/cdo-web/search?datasetid=GHCND)（作者使用的是气象站ID USW00024233的数据），我们可以使用Pandas很容易地联合两个数据集。然后我们使用简单的线性回归来拟合相关的天气以及其他因素和自行车数量，以此来估计给定一天的任何其中一个参数改变对骑行者数量的影响。\n",
    "\n",
    "> In particular, this is an example of how the tools of Scikit-Learn can be used in a statistical modeling framework, in which the parameters of the model are assumed to have interpretable meaning.\n",
    "As discussed previously, this is not a standard approach within machine learning, but such interpretation is possible for some models.\n",
    "\n",
    "特别这是在统计模型框架中使用Scikit-Learn工具的特别例子，其中的模型参数被认为是有可解释的含义的。正如之前讨论的，这不是机器学期的标准方法，但是对于一些模型来说这样的解释是存在的。\n",
    "\n",
    "> Let's start by loading the two datasets, indexing by date:\n",
    "\n",
    "让我们首先载入两个数据集，使用日期进行索引："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# !curl -o FremontBridge.csv https://data.seattle.gov/api/views/65db-xm6k/rows.csv?accessType=DOWNLOAD"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "counts = pd.read_csv('data/FremontBridge.csv', index_col='Date', parse_dates=True)\n",
    "weather = pd.read_csv('data/BicycleWeather.csv', index_col='DATE', parse_dates=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Next we will compute the total daily bicycle traffic, and put this in its own dataframe:\n",
    "\n",
    "然后我们计算每天自行车的总流量，把这个数据放进它自己的DataFrame中："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "daily = counts.resample('d').sum()\n",
    "daily['Total'] = daily.sum(axis=1)\n",
    "daily = daily[['Total']] # 移除其他列"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We saw previously that the patterns of use generally vary from day to day; let's account for this in our data by adding binary columns that indicate the day of the week:\n",
    "\n",
    "我们之前看到自行车流量随着星期天数而发生不同变化；因此让我们将这点也考虑进来，为这个数据集增加7个布尔值的列表示星期天数："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']\n",
    "for i in range(7):\n",
    "    daily[days[i]] = (daily.index.dayofweek == i).astype(float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Similarly, we might expect riders to behave differently on holidays; let's add an indicator of this as well:\n",
    "\n",
    "类似的，我们也期望骑手们在节日会有不同习惯；让我们将这点也考虑进来，加入一个标识列："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pandas.tseries.holiday import USFederalHolidayCalendar\n",
    "cal = USFederalHolidayCalendar()\n",
    "holidays = cal.holidays('2012', '2016')\n",
    "daily = daily.join(pd.Series(1, index=holidays, name='holiday'))\n",
    "daily['holiday'].fillna(0, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We also might suspect that the hours of daylight would affect how many people ride; let's use the standard astronomical calculation to add this information:\n",
    "\n",
    "我们同样猜测日照时间也会影响多少人骑自行车；我们使用标准天文计算来增加这个信息："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 17)"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXQAAAEbCAYAAADKwX/cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3deXxU9b3/8ddM9j0hOwlZCOQLhH3fNxUEWURQW8W1VmtraW9r721v+7utt9fe9l57a61Wa6vVuosgisoqW0BWZRe+kJUQAoSQfU9mfn/MYCNbtpmcWT7Px4MH4ZycM+98mXxycs53MVmtVoQQQrg/s9EBhBBCOIYUdCGE8BBS0IUQwkNIQRdCCA8hBV0IITyEFHQhhPAQvu19glLqKWAxkAYM0VofUUqlAavafFokEK617uWMkEIIIdrXbkHHVrj/CGRf2qC1LgCGX/q3UurpDp5LCCGEk7RbhLXW2wGUUlfdr5TyB+4GZnfytQOAMUAJ0NrJY4UQwlv5AInAXqCx7Q5HXFUvAIq11l908rgxtLnqF0II0SlTgO1tNziioD8IvNyF40oAystrsVhk+oHo6FDKymqMjuESpC2+TtrjSt7cJmaziaioELDX0La6VdCVUr2BacA9XTi8FcBisUpBt5N2+Cdpi6+T9riStMmVt6q7223xfuBjrXVZN88jhBCim9ot6EqpZ5RSp4FkYKNS6mib3ffTtdstQgghHKwjvVyWAcuusS/T4YmEEEJ0ifQdF8LLtLa2UF5eSktLk9FRuuz8eTMWi8XoGE7l6+tPVFQsPj4dL9NS0IXwMuXlpQQGBhMSkoDJZDI6Tpf4+pppafHcgm61WqmtraK8vJSYmMQOHydzuQjhZVpamggJCXfbYu4NTCYTISHhnf4tSgq6EF5Iirnr68r/kRR0IYTwEFLQhRDCQ0hBF0K4lMmTR1NXV9elYx977GF27LBNEfW3v73Ap5+ub/eYl176C88++/RV933xxT727NnV7jmefPJXrFjxTufCOoH0chHCi+04XML2Q1dMCeIQk4cmMmlIx3toONpDD32n2+fYv/9z6uvrGTt2vAMSQUtLC76+ziu7UtCFEIbaunUTf/nLc4SHRzB+/MSvtj/xxC84daqQ5uYmkpL68LOf/Qfh4eE8/vgyFiy4lalTZ351/KpVK/jDH5772nmffPJXDBgwkMWL76Smpob//u8nyM/PIzY2jpiYWKKievHYYz8EoLT0PI8/vowzZ4pJSkrm17/+HcXFp/ngg5VYLBb27dvDDTfM4p577r/m15GXl8uyZd/h/PlzZGUN4Re/eAKTycSTT/6K4OBgioqKqKgo589//hv/9V+/pKAgDx8fX1JSUvn1r3/rkLaUgi6EF5s0xNir6PLyi/zud0/ywgsvkZKSxhtvvPrVvh/84HEiIyMBePHFP/PGG6/y6KPfZ8mSb/Dmm//4qqCvXLmcJUvuvO7r/P3vfyUsLJw331xBVVUl3/rWPUybNvOr/Vof469//QehoaH86EePsX79GhYsWMTChbdRX1//VeG/nry8XJ5++s+YzWYeeOBu9u3bzZgxtiv7I0cO8+yzLxIUFMTWrZuprq7m9deXA1BVVdW5RrsOuYcuhDDM0aOHycxUpKSkAbBgwW1f7Vu79iMefHAp9957Jxs2rOPkyRMAjBs3gbKyCxQU5FNYWEBx8WkmTpxy3dfZv38fc+fOByA8PIIpU6Z9bf/YseMJCwvDZDIxaNBgiotPd/prmTJlOgEBAfj5+aGU+to5pk+/gaCgIAD69evPqVMF/P73v2PTpo34+/t3+rWuRa7QhRCGsVqvPgXuyZOaVatW8PzzLxMVFcX69Wv58MOVgK1/9pIld/D++7Yr3IULb8PHx6fd17lev25//4CvPjabzbS2dn4RtYCAfxZms9nna+cIDg766uOkpGTeeGM5+/btZdeuHbz44nO8+urbBAQE0F1yhS6EMMzgwUM5eVJTVHQKgNWrbWvPV1dXExISSkREBE1NTXz88YdfO27u3PlkZ2/l0083MG/ere2+zsiRo1mz5iPAdosjO3tbh/KFhIRQW+vYhTTOnz+H2ezD1KnTWbbsx1RUlFNd7ZjbLnKFLoQwTFRUL/71X3/Ov/3bvxAeHsHMmTcCtgK8fv0a7rprCXFxcQwYMJAvv/znzN0hISGMGzeBxsZGoqKi2n2d++//Nr/5zRMsXXoHiYmJDB06lNDQ0HaPmzp1Bj//+U+4//672n0o2lG5uTm88MKzAFgsrSxdej8xMbHdPi+A6Vq/8vSANCC/rKxGVh4BYmPDKC2tNjqGS5C2+DpHt8fZs4UkJKQ67HzGsLB06Z38/Oe/YuDArHY/u6WlhdbWVgICAqitreG7332Ixx77F8aMGdcDWbvuav9XZrOJ6OhQgHSgoO2+dq/QlVJPAYuxFeAhWusj9u2BwB+AG4EGYKfW+uFufwVCCHEd27dv5emn/5cpU2Z0qJgDVFdX8eMfL8NisdDU1MhNN93s8sW8Kzpyy2UV8Ecg+7Lt/4OtkGdqra1KqXhHhxNCiMtNnjyN6dNndGr63KioXrz88uvdet2TJzVPPvnEFdsXL76D+fPbv4/fEzqyYtF2AKXUV9uUUqHAvUCy1tpq/7xzTsoohHCw9np9iCv176945ZU3e+z1unI7vKsPRTOAMuCXSqkZQA3wi0vFvzPs94IEtnulwkba4usc2R7V1cHU11cTFhbh1kXd19dzO+lZrVaqq6sICQnu1P99Vwu6L9AX2K+1/olSahywWinVT2vdqf438lDURh4E/pO0xdc5uj2Cg6MoLy+lqqrcYefsaWaz9yxBd/n/fZuHolce08XXKgRagLcAtNa7lVIXgExgXxfPKYToAT4+vp1a1swVyQ/9q+vS7yxa6wvAZuAmAKVUJhAH5DgumhBCiM5ot6ArpZ5RSp0GkoGNSqlLvfu/A/y7Uuow8DZwj9a6wnlRhfBMrRaL3HYUDtGRXi7LgGVX2Z4HTHdCJiE8Vnl1I4fzysg5XUnB2SoqapqoqW8GwNfHRERIAEmxIaTGhzE0I5r03uEGJxbuRIb+C+FkrRYLe4+fJ/tgCccLy7ECoUF+9O0dTv/kSMJD/DEBjc2tXKxupLi0hiN5F1n9WQHhIf7MHp/K+AFxRIV1f/Im4dmkoAvhJBarlR2HS/j4s0LOV9QTFxnE/ElpjBkYT+/o4Ot2Gaypb+ZIXhl7jp3nvU0nWbk5h8lDE7l1cjoRoVLYxdVJQRfCCQrOVvHauhPkl1SRmhDGY7cNYXj/GMwd7PcdGuTH+KwExmcl0Go28/ba42w5UMyuo+eYPymN2WP74GP23H7YomukoAvhQK0WC6t3FLD6swLCgv359rxBjM+K79YAnoToEO6elcmNo5N5d3MO723J5XNdykPzBpIYHeLA9MLdSUEXwkEuVjXwwgdHySmuZOLgBO66sT/BgX4OO398r2Aeu20Ie46d5/X1mide2csDcwYybpBMoyRspKAL4QC5Zyr504rDNDW38vD8QYzPSnDK65hMJsYNikelRPL8qiP85cOj5JdUcfuMDLkFI6SgC9Fd+46f568ffUlEiD8/+eYIkmKcfxskMjSAn3xzBO98msP6vUWUVtTzyIIs/P2uvxSb8GzyI12Ibth+qITnPzhCakIYv7hvdI8U80t8fczcPSuTu27sz4GTF/i/dw5Q19DcY68vXI8UdCG6aPP+Yl7+5BiDUqP48Z3DCQ923OrtnXHj6D48sjCL3DNV/P6dA9Q1tBiSQxhPCroQXbBxXxGvrdMMy4hm2ZKhBBh8q2PswHi+t2gIp87V8IflB6hvlKLujaSgC9FJO4+c5c2NJxmZGcv3bhuCn69r3Lce3j+G7yzMIv9MNX9cfpDGplajI4keJgVdiE44lFvGy58cY2BqFI8syMLXx7W+hUapOB5eMIiTxZU8/8ERWj18znDxda71bhTCheUWV/LnVYdJjg3lsduG4OeiK+aMHRjP0lmKQ7llvLnhZJeWMhPuSbotCtEBZZUNPLPiEJEhAfzwjmEEBbj2t86MEUmUVtSzdvcpYiODuHlcitGRRA9w7XelEC6gsamVP604REurhR/cPpSIEGN6s3TWkukZXKhs4N3NOcRGBjFKxRodSTiZa/7OKISLsFqtvPTxlxSdr+GRBYPdau4Us8nEt+cNJD0xnL99/CUlZbVGRxJO1qGCrpR6SimVr5SyKqUGt9leoJQ6rpQ6YP8z23lRheh5H+0sZJ8u5fYZ/RiaEW10nE7z8/Xhe4sG4+9r5tmVh6U7o4fr6BX6KmAqtsWhL7dEaz3c/med46IJYaxjBRdZtS2P8YPimT22j9FxuqxXeCDfWTiYcxfreenjY/KQ1IN1qKBrrbdrrYucHUYIV1FZ08hfVn9JQnQw996sujX9rSsYmBrF7TMy+OJEKev2yLeyp3LEQ9E3lFImYDvw751dKDo6OtQBETxDbGyY0RFchpFt0Wqx8vR7h2hoauU3j06iT6Lx63o6oj3unjuIU6W1rNyWy4RhSfTrE+mAZMaR75crdbegT9FaFymlAoCngWeBpZ05QVlZjax4ju3NWVpabXQMl2B0W6zKzuNQzgUenDuQYF+T4f8vjmyPb87sx/GCi/z21T388oExBPq7Z0c3o98jRjKbTde8EO5WL5dLt2G01o3An4FJ3TmfEEbLLa7ko88KmZCVwOShiUbHcbjQID8enj+I8+X1vLHhhNFxhIN1uaArpUKUUhH2j03AN4ADjgomRE9raGrhrx99SVRYAHfflGl0HKdRKVHcMjGNHYfPsvvLc0bHEQ7U0W6LzyilTgPJwEal1FEgHtiilDoEHAEyge86LakQTvbuphxKy+t5aN5AggPd81ZERy2cnEZGUjj/WHecssoGo+MIB+nQu1ZrvQxYdpVdIxwbRwhjHMy5wJYDZ7h5XAoqJcroOE7nYzbz8Pws/uOlPbyy5hg/unO42/fkETJSVAiq6pr4+5rjJMeGsGhKX6Pj9JjYyCDumJHB0YJyth48Y3Qc4QBS0IXXe3PDCWrrm/n2/CyXnUHRWaaNSGJgahTvbMrhQmW90XFEN3nXu1eIyxw4eYE9x84zf2IafeK8b0yE2WTigTkDAPj7J8dlFKmbk4IuvFZdQwuvrdckxYYwd0Kq0XEMExMZxJ0z+nGssJwtB+TWizuTgi681ntbc6moaeSBOQNdbuWhnjZteG8GpUXx7uYcLlZJrxd35d3vYuG19Klytuwv5qbRfejb2/ih/UYzmUzce/MALBYrb248aXQc0UVS0IXXaWpu5ZU1x4mJCPSqXi3tiYsMYsGkNL44Ucr+E6VGxxFdIAVdeJ0PdxRwrrye++YMIMDfx+g4LmX22BSSYkN4fcMJmTvdDUlBF16luLSGdXtOMWlIAllpvYyO43J8fczcd/MAyqsbWZWdb3Qc0UlS0IXXsFqtvLb+BIH+Ptwxo5/RcVxWv6QIpo9IYuPnRRScrTI6jugEKejCa+w8epYTRRUsnp5BWLB7LPRslCXT+hIW7M+razStFovRcUQHSUEXXqGuoZl3N+WQnhjO1GG9jY7j8oID/bjrxv4Unqtm8xfFRscRHSQFXXiF97flU13XzD2zMzHLJFQdMmZAHANTo1iVnU9VXZPRcUQHSEEXHq/wbDWb9p9m+sgk0hKkz3lHmUwm7ropk8bmVlZuzTU6jugAKejCo1msVl5brwkN8uO2qdLnvLOSYkK4YVQy2QdLyC+RB6SurqMLXDyllMpXSlmVUoOvsv+X19onhJF2HCoh70wVd8zoR0ign9Fx3NKCSemEhfjzxoYTWGTyLpfW0Sv0VcBUoPDyHUqpkcB44JQDcwnRbfWNLazYlkdGUjgTBycYHcdtBQf6smRaBnlnqvjs8Fmj44jr6FBB11pvv7QgdFtKqQDgOWxLz8mPbuFSPtpZQFVtE3fdmCmr8XTTxCEJZPQO570tOdQ1yAhSV9XdhRP/E3hda52vlOrSCaKjvW8O6muJjQ0zOoLL6G5blFyoZcPe08wc3YexQ5MclMo4rvDe+N4dw/nxH7excX8x31pg/N1VV2gTV9Plgq6UmgCMAX7anQBlZTVYLHJxHxsbRmlptdExXIIj2uL5FYfwMZu4ZVyK27erq7w3IgN9mTI0kdXZeYzuH0PvmBDDsrhKmxjBbDZd80K4O71cpgEDgHylVAGQDKxTSs3qxjmF6LZjBRfZf/ICt0xIJSoswOg4HuW2aRkE+Pnw1qcyxa4r6vIVutb6t8BvL/3bXtTnaa2PdD+WEF3TarHw1qcniYkIZPbYPkbH8Tjhwf4smJTG25tyOJxXxpC+0UZHEm10tNviM0qp09iuwjcqpY46N5YQXbPtYAmnS2u5Y0Y//HxlalxnmDkqmbioIN7ZlCPzvLiYDl2ha62XAcva+Zw0RwQSoqvqGpp5f1semX0iGaVijY7jsXx9zNw+vR/PvX+Y7IMlTB/h/g+dPYWMFBUe48MdBdTWN/PNG/pLN0UnG5kZQ2afSN7PzpOFMFyIFHThEc5erOPTz08zZVgiqQnSnc3ZTCYT37ihH9V1zXy884rxhsIgUtCFR1i+OQc/XzOLpmYYHcVrpCWEMyErgfV7i7hQUW90HIEUdOEBThRVsP/kBeaMTyUiRBau6EmLp/XFbIL3ZDZGlyAFXbg1q9XK8s05RIb6M2uMdFPsab3CA5k9NoU9x86TW1xpdByvJwVduLXPdSm5Z6q4dUpfAvykm6IR5oxPISLEn7c3ncQqszEaSgq6cFstrRbe25pLUkwIk4ckGh3HawX6+3Lb1L7kFlex9/h5o+N4NSnowm1tPXCG8+X13D4jA7NZuikaadKQRJJjQ1mxNZeWVhlsZBQp6MIt1TW08MH2fAakRMrwcxdgNpu4fUYGpRUNbNkvi0obRQq6cEtrdhdSU9/MHTP7ySAiFzE4vRcDU6P4cEeBDDYyiBR04XYuVjWwfm8R4wfFy6LPLsRkMrFkegY19c2s3S0LmBlBCrpwO6uy87FarbLoswtKTwxn7MA41u09RUVNo9FxvI4UdOFWTp+vYcfhEm4YlUxMZJDRccRVLJral9ZWKx/uKDA6iteRgi7cyrtbcggK8OWWCWlGRxHXEB8VzPThSWw7cIaSslqj43gVKejCbRwtuMiRvIvMm5hGaJCf0XHEdcyflIafn5mVW/OMjuJV2p0PXSn1FLAYSAOGXFqRSCm1CkgHLEAN8H2t9QHnRRXezGK18t7mXKLDA7lhlMy/7erCQ/yZMzaFVdvzyS2uJCMpwuhIXqEjV+irgKnA5XNk3qe1Hqa1HgE8Bbzs6HBCXLLv+HkKz1WzaGq6rETkJmaN7UN4iD/LN+fIlAA9pN2CrrXerrUuusr2tjPxRGC7UhfC4VpaLby/LY+k2BDGD0owOo7ooEB/XxZOSuPE6UoO5pYZHccrdHmRaACl1N+AWYAJuLkr54iODu1OBI8SGysLM1zSti3W7izgXHk9/+/BccTHe2e/c3d9b9x2o+LTL4pZtT2fmePS8HHgFA3u2ibO1K2CrrV+CEApdQ/wv8Dczp6jrKwGi0V+HYuNDaO0tNroGC6hbVs0Nbfyxtpj9EuKIC022CvbyN3fG7dOTufPq47wwaYTTBnW2yHndPc26Q6z2XTNC2GH9HLRWr8GzFBKyaQawqE+/eI0FTVNLJmeIUP83dQoFUt6YjirtufT1NxqdByP1qWCrpQKVUr1afPv+cBF+x8hHKKuoZlPdhYypG80mX0ijY4jushkMnH79AzKqxvZ9IVM3OVMHem2+AxwG5AAbFRKlQEzgeVKqRCgFVshn6+1lnsnwmHW7D5FbUMLi6fJEH93NyA1iqz0Xny8s4Cpw3oTHNitu73iGtptVa31MmDZVXaNd3wcIWwqaxrZsK+IcYPiSYmXh1+eYPG0vvznK/tYt+cUi2QeHqeQkaLCJa3+rIDWViu3Tkk3OopwkLSEcEYPiGP93iKqapuMjuORpKALl3O2rJatB84wdVhv4qOCjY4jHGjRlHSaWyx8tLPA6CgeSQq6cDlvrD2Oj9nE/ElpRkcRDpYYHcKkIQls2V/Mhcp6o+N4HCnowqUUna9h6/7T3Di6D5GhAUbHEU6wcHI6YOLD7QVGR/E4UtCFS1m5NZfgQD/mjE8xOopwkl7hgcwcmcSOIyWcuSDT6zqSFHThMk4UVXAwt4wlM/sTEijT43qyuRNS8ffz4f1smV7XkaSgC5dgtVp5b2suEaH+zJssPVs8XXiwP7PH9OFzXUp+SZXRcTyGFHThEg7llpFzupIFk9IJ9JdBJ95g9tgUQoP8WLk11+goHkMKujCcxWplxdY84iKDmDI00eg4oocEBfgyb0IqRwvKOVYgs4Y4ghR0Ybg9X57jdGkNi6b2xddH3pLeZMbIJHqFB/De1jxZBMMB5LtHGKql1cL72XmkxIUyZmCc0XFED/Pz9WHBpHTyS6rYf/KC0XHcnhR0YahtB89QWtHAbdMyMMv0uF5p0pAEEnoFs3JbnqyN0E1S0IVhGptaWb2jgMw+kQzp28voOMIgPmYzi6b25cyFWnYePWt0HLcmBV0YZuPnRVTWNrFkmixe4e1GqVhS48P4YHs+La2yPHFXSUEXhqipb+aTXacY3i+GfskRRscRBjObTCye1pcLlQ1sPXDG6Dhuq0MdfpVSTwGLgTRgiNb6iH25udeADKARyAEe0VqXOimr8CBrdhfS0NjCbTIvtrDLSu/FgJRIVn9WwOQhiQT4+xgdye109Ap9FTAVKGyzzQr8j9Zaaa2HArnAbx2cT3igippGPt13mnFZ8STHXX2xW+F9TCYTi6dlUFXbxIZ9RUbHcUsdKuha6+1a66LLtl3UWm9ps2kXkOrAbMJDrd5RQKvFyq0yxF9cJiMpguH9Yliz+xQ19c1Gx3E7DhljrZQyA48CH3b22OhouUK7JDbW85daK7lQy7aDZ5g1PpWszPhrfp43tEVneFN7PHTrEL7/+81sPVTC/fOyrvl53tQmHeWoSTP+BNQAz3b2wLKyGul7iu3NWVpabXQMp3t59VF8zCZuGpl0za/XW9qio7ytPYJ9TYwfFM/q7DwmDoonKuzKefG9rU3aMptN17wQ7nYvF/sD0/7AnVpr6W8krun0+Rp2Hz3HDaOTZfEKcV0Lp/Sl1WJl9WcFRkdxK90q6EqpJ4FRwK1a60bHRBKeauW2PAIDfJk7Xh61iOuLiwxi2vDeZB88w7nyOqPjuI0OFXSl1DNKqdNAMrBRKXVUKZUF/DvQG/hMKXVAKfW+E7MKN5ZzupIDOReYMy5FFq8QHTJ/Yho+PiZWZecbHcVtdOgeutZ6GbDsKrtkeJ9ol9VqZcXWXMJD/LlpdB+j4wg3EREawKwxffjos0LmjEshJV4egrZHRooKpzuafxFdVMH8iWkyWER0ys1jUwgJ9GXFVlmqriOkoAunurR4RUxEINOG9zY6jnAzwYF+zJ2QyuG8MvSpcqPjuDwp6MKpPtelFJ6rZuHkdFm8QnTJDSOTiQz1Z4UsgtEu+Q4TTtNqsfD+tjySYkKYkJVgdBzhpvz9fFgwOZ2c4koO5pQZHcelSUEXTrPj8FnOXqxj0dS+mM3y/Fx03eQhicRHBbFiW64MRLwOKejCKZpbWvlgez59e4czon+M0XGEm/P1sS2CUVxay+4vzxkdx2VJQRdOsfmLYsqrG1k8ta8sXiEcYvSAOFLiQ3k/O4/mFhmUfjVS0IXD1Te28NHOQgalRTEwTZaWE45hNplYMi2DC5UNrNtVYHQclyQFXTjc+r1F1NQ3s3hahtFRhIe5tAjGOxtP0NDUYnQclyMFXThUdV0T6/acYmRmLOmJ4UbHER7m0iIYFdWNbNh32ug4LkcKunCoj3cW0tjcyiJZWk44SUZSBOOyEli7u1AWwbiMFHThMBerGtj0RTETsxJIigkxOo7wYPfMHUhDYyuf7Cps/5O9iOEFvaJGZt31FB/uyMdqtbJQlpYTTpaaEM6EwQl8+vlpLlY1GB3HZRhe0NfvlcVgPcHZi3VsP3SW6SOSiIkMMjqO8AK3Tk7HYrHy4Y4Co6O4DMML+uf6PKdLa4yOIbpp5bY8/HzNzJuYZnQU4SViIoOYMSKJ7YdKOHtRFsGADhR0pdRTSql8pZRVKTW4ve2dFeDny0qZGtOt5Z2pYt/x88we24eIEH+j4wgvMm9iGn6+Zt7fJjUEOnaFvgqYClz+9OFa2ztlxojeHMi5wImiiu6cRhjEarXy3pYcwoL9mD02xeg4wsuEh/gza0wf9h4/T+FZ71w0uq12C7rWervW+oob3dfa3lmThvYmMtSf5VtyZGpMN3Q47yLHT1WwYFI6QQEdWgBLCIeaPTaF0CA/VmzNNTqK4Qz/DkyMD2fpnEE8u/wAuedqmTAk0ehIhomNda8ltlotVla9uo/E6BAW36jw83XcIxl3awtnk/a4Uts2uePGTF5efZSSygaG9os1MJWxDC/oZWU1DEuPJDE6mL+vPkJ6XDA+ZsOf1fa42NgwSkvd61fGHYdLKCip4jsLs6gor3XYed2xLZxJ2uNKl7fJ2MwY3g8L4KUPjvDze0Z59IRwZrOJ6OjQq+/r4SxX5WM2s3haBiVldew4fNboOKIDmltaWZWdR2pCGKMHxBkdR3g5fz8fFk5OJ+9MFftPXjA6jmFcoqADjOgfQ0ZSOB9sz6exudXoOKIdm74opqyqkdunZ2D24Ksh4T4mDUkgMTqY97bk0tLqndPrdqTb4jNKqdNAMrBRKXX0etu7ymQycfv0fpRXN/Lp5zLpjiura2jmo88KGJzei0EyPa5wET5mM0umZ3D2Yh3Zh0qMjmOIdu+ha62XAcs6ur07MvtEMiwjmo93FjJ1WG9Cg/wceXrhIJ/sOkVdQwtLpsv0uMK1DO8XQ2ZyBB9k5zF+ULzX9bxymVsulyyenkFDYwuf7JRJd1xReXUjG/YVMT4rnpR46XkhXIvJZOKOmf2pqmtm7e5TRsfpcS5X0JNjQ5k4JIGNn5+mrFIm3XE1H2zPw2q1smiKTI8rXFPf3uGMHRjHur2nKK/2rsn/XK6gA9w62VYsVm2X4byupPhCLdmHSkmkzHoAABebSURBVJgxIlkm4BIu7bZpGbS2WvnAy2qISxb06IhAbhyVzGeHz3L6vEzc5SpWbs0l0N+HeRNTjY4ixHXFRQYxc2Qy2YdKKPaiyf9csqADzJ2QSlCAL+9uyTE6igD0qXL2n7zAnHGphAXLBFzC9c2flEagvy/Lt3jPlAAuW9BDg/yYPymNI3kXOZJXZnQcr2axWnl7Uw69wgOYNaaP0XGE6JDQID/mTUjlUG4ZxwouGh2nR7hsQQeYOTKZuMgg3tmcg8UiE3cZZdfRsxSerWbxtAz8/XyMjiNEh904Opno8ADe3ZyLxQsm/3Ppgu7naxsoUFxaS/ahM0bH8UqNza2s2JpHWkIY4wbFGx1HiE7x8/XhtqkZFJ6rZveX54yO43QuXdABRqlY+idH8P62POobW4yO43XW77F1/frGDf1liL9wS+Oy4kmJD2Xl1jyaWzx7WhGXL+gmk4k77QMF1uyWwUY9qbKmkU92nWJUZiyZfSKNjiNEl5hNJu6Y0Y+yqgY+/bzY6DhO5fIFHWwDBcYPimfdniJZ4bsHvZ+dT0urhSUzZIi/cG+D0noxpG80qz8roLquyeg4TuMWBR3gtml9sVqRVUl6yOnzNWQfOsPMkcnERwUbHUeIbrtjZj8am1pZlZ1vdBSncZuCHhMRxOyxfdh59Bz5JVVGx/F472zOITjAl/mT0oyOIoRDJMWEMGNEElsOFHvsgEW3KegAc8enEh7sxzubZP1RZzqcV8bR/IvMn5QuM14Kj7JwSjrBAb689elJj6whblXQgwJ8WTilLyeKKvjiRKnRcTxSS6uFdzblEBcVxMyRSUbHEcKhQoP8WDg5nWOF5RzI8byVjTqywMVTSql8pZRVKTW4zfZMpdROpdQJ+9/9nRvVZuqwRJJiQ3hnUw5NsrKRw23eX8yZC7XcMaMfvj5u9fNeiA6ZPiKJxOhg3tmUQ3OLZ61s1JHv2FXAVODyPoMvAM9prTOB54C/ODjbVfmYzdx1YyYXKhtYu8f75jt2pqq6JlZl55OV3osR/WOMjiOEU/j6mPnGDf05X17vcaujtVvQtdbbtdZFbbcppeKAkcBb9k1vASOVUrGOj3ilgalRjB4Qxyc7C7lQWd8TL+kVVm7Npam5lbtu7O/Rq6YLMaRvNEMzoln9WT5VtZ7TjbGr6zP1AYq11q0AWutWpdQZ+/ZO3dyOjg7tUoBHlwzj0d9t4oPPCvnpvWO6dA5XExtr3ApAJ4vKyT5UwsKpGQwdkGBYjkuMbAtXJO1xpe62yaNLhvHY/25mzd4iHrt9uINSGcvwBffKymq6NPGWCZg7PoVV2fls23eKgalRjg/Xg2JjwygtrTbktS1WK88tP0BYsD83jUwyLMclRraFK5L2uJIj2iTAZJsAcP2uQsYPiCM1wT1+aJrNpmteCHf1qVcRkKSU8gGw/93bvr3H3Dw2hZiIQN7ceIJWi2c93OhJu46eJbe4iiXTMrxuUV3h3RZOTiMs2I/X12uPmI2xSwVda30eOAB8077pm8B+rXWP9iX09/Phzpn9KS6tZfMXnj1Hg7PUN7awfHMu6YnhTBxi/K0WIXpScKAft8/oR+6ZKrYfKjE6Trd1pNviM0qp00AysFEpddS+6zvA95VSJ4Dv2//d40ZmxjAoLYpV2flUefAcDc6y+rMCKmubuPumTJlNUXiliYMT6J8cwXtbcqmpbzY6Tre0+/u11noZsOwq248D45wRqjNMJhN33ZjJL1/ew4otuTwwd6DRkdxGSVktG/YWMXloIn17hxsdRwhDmEwmls5SPPH3vazclse9s5XRkbrMI0aO9I4J4abRfcg+VMKJogqj47gFq9XKP9ZqAv19WDJNZlMU3q1PXCg3jEpm6/5it54ryiMKOsDCyelEhwfw2jpNS6s8IG3PjsNn0UUVLJmeQXiILPosxMLJ6YSH+Lv1A1KPKegB/j7cfZOi+EIt62QE6XVV1zXx7uYc+iVHMGVYb6PjCOESggN9uWNmP/JLqtl20D2XvPSYgg4wvH8MIzNjWb2jgNIKGUF6Lcs351Lf2MK9s5U8CBWijfGD4hmQEsl7m3OpqGk0Ok6neVRBB2zD1s0mXl9/wiOnx+wufaqc7YdLmD02heTYro3SFcJTmUwm7r15AE0tFt7YcMLoOJ3mcQW9V3ggt03py+G8Mvb1bLd4l9fcYuEf6zQxEYGycIUQ15DQK5iFk9P4XJfyuZvVEI8r6AA3jEomNT6MNzecoK7BvfuVOtLa3YWUlNWxdJYiwM/H6DhCuKxLv8G+vkG7VQ3xyIJuNpu4b46iuq6ZtzflGB3HJZwureHDHQWMHRjH0Ixoo+MI4dJ8fcw8MHcAVbVNvLfFfdYx9siCDpCWEM6c8SlsP1TC4bwyo+MYqtVi4eWPjxEc6MtdN2UaHUcIt5CeGM5No/uw5cAZ9Klyo+N0iMcWdIAFk9LpHRPCK2uOU9fQYnQcw6zdfYqCs9UsnaUID5Y+50J01KIpfYmJCOSVtdotVkjz6ILu52vmwbkDqahp5N3NJ42OY4jiC7V8sD2f0SqWMQPijI4jhFsJ8PfhvjkDOHexjhVb84yO0y6PLugAfXuHc/O4FLYdLOFIvnfderl0qyXQ35els9x3fgohjJSV1ouZI5PYsK+IY4WufevF4ws6wK2T00mMDubvnxyn1o2eWHfXml2nyC+pYumsTBneL0Q33D69H/FRQbz08ZcuffvWKwq6n68PD80bRFVtE6+uOe4VA45yz1SyKjufsQPj5FaLEN0U4O/DQ/MHUV7dyJsbXXfAkVcUdLA9sV40tS/7dKlHTGR/PfWNLbz44VGiwvy5d7aSBZ+FcICM3hHcMiGNz46c5XN93ug4V9Xt9caUUrcAvwb8gIvA/Vrr/O6e1xluHpfCkbwy3tx4ksw+kcT3CjY6klO8ueEEFyob+Le7RhIc6Gd0HCE8xoJJaRzOLeOVNcdJTwynV3ig0ZG+pltX6EqpKOBV4Bta6yHAX4HnHRHMGcwmEw/NG4Svj4m/fHjUI6fZ3XPsHDuOnGXehDQy+0QaHUcIj+LrY+aRhVm0WKy88IHr1ZDu3nLpB5zTWl+6qfQJMFspFdPN8zpNr/BA7p8zgIKz1ax0g25InXG+op5X12oyeoezYHKa0XGE8EgJvYK572ZFTnEl729zrRrS3YJ+AkhQSo2x//tu+98p3TyvU41SccwYkcTaPadc9l5YZzU1t/LnlYcxAQ8vyMLH7DWPR4ToceMHJTB9eG/W7D7FwZwLRsf5iqm7PT6UUjcCvwICgTXAY8BUrfXhdg5NAwy7197c0spPn9tO0bka/u+HU0mOCzMqSrdZrVb++M5+Pt1bxH98axxjBiUYHUkIj9fU3Mrjz2zjQkU9f/zRDGKjgno6QjpQ0HZDtwt6W0qpeKAQiNZa17bz6WlAfllZDRaLMd0IyyobeOKVvUSE+POLe0cT4G/cDISxsWGUllZ36dgtB4r5x1rNgklp3Dqlr4OT9bzutIUnkva4kqu0ybmLdTzxyl4SegXz07tH4t8Ds5iazSaio0PhKgW927+XK6US7H+bgd8AL3SgmLuE6IhAHlmYxZmyWv728ZduuY7gydMVvLnhBIPTe7FgUrrRcYTwKvG9gvn2/EEUnq3m5U+OGT7GxRE3Wv9LKXUMOAk0AT91wDl7TFZaL+6Y0Y/PdanbPSQ9X17Hn1YcJjo8kIcXZGE2S39zIXraiP6xLJ6ewZ5j5/loZ6GhWbrdD11r/ZAjghhp1pg+nLtYxye7ComPCnKLhZNrG5p5evkhrFYrP7x9GKFB0t9cCKPMGZdCcWkN72/LI7FXMKMNGp0tXSGwrSN4102ZZKX34h/rNEcLLhod6bqaWyw8t/IwpRX1fH/xUI8dICWEuzCZTNw/ZwAZSeG8uPqoYZN4SUG38/Ux8+jCwSREB/PsisPknK40OtJVtbRaeH7VEY6fquDBuQNl8JAQLsLP14cfLBlGfFQwz6w4RH5JVY9nkILeRnCgL4/fOZzIUH/+sPwABWd7/j/keiwWK3/76EsO5Fzg7psymTBYuicK4UpCg/z40Z3DCQ304w/vHqSkrGf7h0hBv0xEaAA/+eYIggP8+P3bBzh9vsboSABYrFZeWXOcPcfOc/v0DG4YlWx0JCHEVUSFBfD4N4ZjNsHv3tzfozVECvpV9AoP5CffHI6fr5nfvfkFucXG3n5pabXw4odH2X64hAWT0pgzPtXQPEKI64vvFcy/3jXSXtS/6LHbL1LQryEuKpifLR1FSKAfT719wLDVjhqbWvnTisNfXZl7wsAhIbxB75gQfrp0FEEBvvzvW/s53gMPSqWgX0dsZBA/WzqSuKggnn73EBv3FfXowIELFfU8+drnHMkv476blVyZC+Fm4iKD+OndI4kKC+D37xxg64Fip76eFPR2RIQG8NO7RzI0I5o3N57k72uO09gDq39/WXCR/3x1H2VVDfzw9mFMG57k9NcUQjher/BAfn7PKAamRvHqWs1r6zVNTqoh3R5Y5A2CAnx5bPEQVmXn89FnBeScruTb8weRnhju8NdqbmllxdY81u8tIjE6mO8vHkqC9DMXwq0FB/rxg9uH8t6WXNbtKeJEUQWPzM8iOS7Uoa/j0Mm5OikNgyfn6opjBRf528fHqKpt4oZRySyYlE5wYPd/LsbGhrF5dwFvfXqSkrI6ZoxM4o4Z/Qjogcl+XI2rTLzkKqQ9ruTObXIot4yXPzlGbX0zs8b2Yf7ENAL9O15Drjc5lxT0LqhtaGb55hyyD5YQGuzHLRPSmDossVP/KW3lFleybt9p9h07R1xkEHfPymRI32gHp3Yf7vzN6gzSHldy9zapqm1i+eYcdhw5S2SoP3PHpzJlWO8OXcBJQXeSgrNVvLsph+OnKggO8GXy0ERGD4ijb+9wzO0szFxV18T+E6V8duQsJ09XEhrkx83jUrhpdB/8fL370Ya7f7M6mrTHlTylTXKKK3l3Uw45xbYaMGlIAmMHxpOWEHbNxd2loDtZ7plK1u0+xYGcC7S0WgkP9iMtMZyU+DDCg/0IDvSlucVCXUML58rrKCippqi0BqsV4qKCuGFUMotmZlJTVW/0l+ISPOWb1VGkPa7kaW1yoqiCdXtOcSi3jFaLlYgQf9ITw0mOCyUixJ/gAF8aW1qpb2wh0N+XO2YNgKsUdHko6gAZvSP47qIh1DW0cDDnAkfyL1J4rprDeWVc/vMyJNCXtIQw5k1IY5SKpU9cKCaTiaAAX1xjTKoQoqdl9okks08ktQ3NfHGilOOFFeSXVHEw5wKXX+727xN5qaBfQQq6AwUH+jJhcMJXc6y0tFqoa2yhvqEFP18zwYG+BPj5XPNXKSGEdwsJ9GPK0N5MGWqbwrvVYqG2oYW6hhYC/HwI9Pe5bicMKehO5OtjJjzYn/Bgf6OjCCHckI/5yhpyvQvCbhd0pdQ84NeACdtApV9prVd297xCCCE6p1vdKZRSJuA14B6t9XBgKfCqfX1RIYQQPcgRt1wsQIT940igRGtt6cBxPoCsg9mGtMU/SVt8nbTHlby1Tdp83Vd0Wu92t0Wl1A3AO0AtEAbcorXe2YFDJwPZ3XpxIYTwXlOA7W03dKugK6V8gbXAL7XWO5RSk4C3gEFa6/Z64QUAY4ASwPmzXQkhhGfwARKBvUBj2x3dveUyHOittd4BYC/qtcBA+4tdTyOX/XQRQgjRIblX29jdh5engWSllAJQSg0EEq71YkIIIZzHEffQ7wZ+iu3hKNhuv6zqbjAhhBCdY+RcLkIIIRxI+osLIYSHkIIuhBAeQgq6EEJ4CCnoQgjhIWS2xR6klCoA5mmtjxgcxXBKqShsg8pe0Fr/0Og8rqIj7xFveB8ppQKA3wC3As1APfDE9XrQKaXSgFla6xd7JKQLkit0YZS7gZ3AN5VSnZpfWClltk8MJzzXn4FkIEtrPQC4B3hWKTX1OsekAQ/3QDaXJVfoBlBK/Rj4Brb2bwAe1VofsO+zAj8HFgHRwE+01iuMyupEDwI/AX4GLADeU0r9ChgEhAKpwHHgQa11pX1fP/u+DGAqUN7zsXvG5Vfh3nBVfolSKhW4E0jRWjcAaK2PKKWeBH4J3KCU+hlwF7bxL7XY5oZ6DkhXSh0AcrTWSwz5AgwkV+jG+IfWeozWegTw/4AXLttfpbUeg+2q5JkeT+dkSqlhQC9gE/B3bMX9kinAA1rrLKASW/tcMhV4SGs9RGvtscVcMARbQb542fZdwDCl1H3YLgImaa2HAfPtM7x+D/hSaz3cG4s5SEE3yiil1Dal1BHg/7DNidPW2/a/dwG9lVKBPZrO+b6F7YeaFVgJjFdKJdn3faS1Pmf/+CVgZpvjPtFaX+jBnMIY7d1Omwc8r7WuAtBalzk/knuQgt7zzMB7wA+11oOBm7HNPNnWpV8zL81C6TG3xuz3y+8CHrTfRjgG+AH3XeXTTfC1NXK9aR3tFr7+/elpP9Sv5zDQTynV67Lt44FDtF/wvZYUdGP4AkX2j79rZBAD3Aoc11ona63TtNZpwCzgAfv+W5RSsfaP7wc293xEl5CLbXrpS2sOxBsbp+dorQuA5cDzl347VUoNxvZs6QlgNfCoUirMvi/afmgV/1xsxytJQe9ZvkAd8B/AXqXUNmwPdLzJA8AbbTfYF0QxY7tH/inwslLqKLb77L/u8YTGuvSg/BfAj5VSu4C5wClDU/W8R4EzwJdKqePA68APtNZbgX9gK+q7lFIHgQ/sy14eArRS6ohS6j2jghtJJufqIUqpRGy9NhK01vVG53FF9p4soVrrx43OYgR5j4jukiv0HqCUWobt1sHj8o0qrkbeI8IR5ApdCCE8hFyhCyGEh/CY7nCuxP7U/TVsIxobgRzgEa11qVJqPPAXIAgoAJZqrc/bj3sDmIFtAdiwSwtt2x/47ACC7S9RAnzH3htACCEAuUJ3FivwP1prpbUeiq0L2m/t84+8DnxPa50JbAN+2+a4l7hykBH2UXA3a62H2UfGrcE2IEkIIb4iV+hOYB+yvKXNpl3YumGNBhq01tvt21/AdpX+oP24TQD2NbcvP2dlm3+G8881XIUQApArdKez3y55FPgQSAEKL+2zD2M3X2VE3LXO9YlS6iy2iYuWOSGuEMKNSUF3vj9hG7L+bHdPpLWeC/QG3sI28EQIIb4iBd2JlFJPAf2BO+33wU9hmxb20v4YwHqVWeWuyX6el7DNxCiEEF+Rgu4k9rmbRwG3aq0b7Zs/B4KUUpPt//4O8G4HzhXbZr4KgNuxTWAkhBBfkYFFTqCUygKOACewLZ0FkK+1XqSUmoit22Ig/+y2eM5+3EpgLJCEbR6LI1rr2UqpIcAr2GYlNAH52GZrzOuxL0oI4fKkoAshhIeQWy5CCOEhpKALIYSHkIIuhBAeQgq6EEJ4CCnoQgjhIaSgCyGEh5DJuYTHU0oVYFtkuQVoBb7Eti7li/aRt9c7Ng1bv38/rXWLU4MK0U1yhS68xXytdRi2qRd+C/wbtikUhPAYcoUuvIp9GuIP7bNW7lJK/R5bkf8vbAuSVAIvaa1/ZT9km/3vCvu0xjdprXcqpR4EfgIkAHuAh7XWhQhhILlCF15Ja70HOA1MAWqBe4FI4BbgUaXUrfZPnWr/O1JrHWov5rcC/w7cBsQC2dhmwBTCUFLQhTc7A/TSWm/RWh/WWlu01oewFedp1znuEeC/tdbH7PfVfwMMV0qlXucYIZxObrkIb5YEXFRKjcN2X30w4A8EAMuvc1wq8Ef77ZpLTPbzyW0XYRgp6MIrKaXGYCvA24FV2BYgmaO1blBKPQ3E2D/1arPXFQFPaq3f6JGwQnSQ3HIRXkUpFa6Umge8DbyutT4MhAEX7cV8LHBXm0NKsa3f2rfNtheAn9mnSUYpFaGUur1nvgIhrk0KuvAWq5VS1diurn8O/B/wgH3fd4H/tO//D9osOqK1rgOeBHYopSqUUuO11u8DvwPeVkpVYZv7fk7PfSlCXJ3Mhy6EEB5CrtCFEMJDSEEXQggPIQVdCCE8hBR0IYTwEFLQhRDCQ0hBF0IIDyEFXQghPIQUdCGE8BD/H+GeiDnOkmDzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "def hours_of_daylight(date, axis=23.44, latitude=47.61):\n",
    "    \"\"\"\n",
    "    计算给定日期的日照时间\n",
    "    axis 23.44 黄赤夹角\n",
    "    latitude 47.61 西雅图纬度\n",
    "    \"\"\"\n",
    "    # 2000年12月21日是冬至日，日照时间最短\n",
    "    days = (date - pd.datetime(2000, 12, 21)).days\n",
    "    m = (1. - np.tan(np.radians(latitude))\n",
    "         * np.tan(np.radians(axis) * np.cos(days * 2 * np.pi / 365.25)))\n",
    "    return 24. * np.degrees(np.arccos(1 - np.clip(m, 0, 2))) / 180.\n",
    "\n",
    "daily['daylight_hrs'] = list(map(hours_of_daylight, daily.index))\n",
    "daily[['daylight_hrs']].plot()\n",
    "plt.ylim(8, 17)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We can also add the average temperature and total precipitation to the data.\n",
    "In addition to the inches of precipitation, let's add a flag that indicates whether a day is dry (has zero precipitation):\n",
    "\n",
    "我们也可以增加平均气温和总降雨量数据。除了单位为英寸的降雨量列外，我们再增加一列标志表示当天是否干燥（降雨量为0）："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 气温单位是0.1摄氏度，求平均值\n",
    "weather['TMIN'] /= 10\n",
    "weather['TMAX'] /= 10\n",
    "weather['Temp (C)'] = 0.5 * (weather['TMIN'] + weather['TMAX'])\n",
    "\n",
    "# 降雨量单位是0.1毫米，转换为英寸\n",
    "weather['PRCP'] /= 254\n",
    "weather['dry day'] = (weather['PRCP'] == 0).astype(int)\n",
    "\n",
    "daily = daily.join(weather[['PRCP', 'Temp (C)', 'dry day']])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Finally, let's add a counter that increases from day 1, and measures how many years have passed.\n",
    "This will let us measure any observed annual increase or decrease in daily crossings:\n",
    "\n",
    "最后，让我们增加一列计数器从第一天开始计数，然后转换成经过的年的小数数值。该列会在每年进行循环："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "daily['annual'] = (daily.index - daily.index[0]).days / 365."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Now our data is in order, and we can take a look at it:\n",
    "\n",
    "现在我们总算准备好了数据，我们看一下："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Total</th>\n",
       "      <th>Mon</th>\n",
       "      <th>Tue</th>\n",
       "      <th>Wed</th>\n",
       "      <th>Thu</th>\n",
       "      <th>Fri</th>\n",
       "      <th>Sat</th>\n",
       "      <th>Sun</th>\n",
       "      <th>holiday</th>\n",
       "      <th>daylight_hrs</th>\n",
       "      <th>PRCP</th>\n",
       "      <th>Temp (C)</th>\n",
       "      <th>dry day</th>\n",
       "      <th>annual</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Date</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>2012-10-03</th>\n",
       "      <td>7042.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.277359</td>\n",
       "      <td>0.0</td>\n",
       "      <td>13.35</td>\n",
       "      <td>1</td>\n",
       "      <td>0.000000</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-10-04</th>\n",
       "      <td>6950.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.219142</td>\n",
       "      <td>0.0</td>\n",
       "      <td>13.60</td>\n",
       "      <td>1</td>\n",
       "      <td>0.002740</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-10-05</th>\n",
       "      <td>6296.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.161038</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.30</td>\n",
       "      <td>1</td>\n",
       "      <td>0.005479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-10-06</th>\n",
       "      <td>4012.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.103056</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.85</td>\n",
       "      <td>1</td>\n",
       "      <td>0.008219</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2012-10-07</th>\n",
       "      <td>4284.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>11.045208</td>\n",
       "      <td>0.0</td>\n",
       "      <td>15.85</td>\n",
       "      <td>1</td>\n",
       "      <td>0.010959</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "             Total  Mon  Tue  Wed  Thu  Fri  Sat  Sun  holiday  daylight_hrs  \\\n",
       "Date                                                                           \n",
       "2012-10-03  7042.0  0.0  0.0  1.0  0.0  0.0  0.0  0.0      0.0     11.277359   \n",
       "2012-10-04  6950.0  0.0  0.0  0.0  1.0  0.0  0.0  0.0      0.0     11.219142   \n",
       "2012-10-05  6296.0  0.0  0.0  0.0  0.0  1.0  0.0  0.0      0.0     11.161038   \n",
       "2012-10-06  4012.0  0.0  0.0  0.0  0.0  0.0  1.0  0.0      0.0     11.103056   \n",
       "2012-10-07  4284.0  0.0  0.0  0.0  0.0  0.0  0.0  1.0      0.0     11.045208   \n",
       "\n",
       "            PRCP  Temp (C)  dry day    annual  \n",
       "Date                                           \n",
       "2012-10-03   0.0     13.35        1  0.000000  \n",
       "2012-10-04   0.0     13.60        1  0.002740  \n",
       "2012-10-05   0.0     15.30        1  0.005479  \n",
       "2012-10-06   0.0     15.85        1  0.008219  \n",
       "2012-10-07   0.0     15.85        1  0.010959  "
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "daily.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With this in place, we can choose the columns to use, and fit a linear regression model to our data.\n",
    "We will set ``fit_intercept = False``, because the daily flags essentially operate as their own day-specific intercepts:\n",
    "\n",
    "有了数据后，我们可以选择使用哪些列来让线性回归模型进行拟合。我们设置`fit_intercept=False`，因为每天的数据都有着那一天自己的截距："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 移除所有有空值的行\n",
    "daily.dropna(axis=0, how='any', inplace=True)\n",
    "\n",
    "# 用来拟合模型的列包括星期几、日照小时数、降水量、是否有雨、气温、该天的年计数\n",
    "column_names = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun', 'holiday',\n",
    "                'daylight_hrs', 'PRCP', 'dry day', 'Temp (C)', 'annual']\n",
    "X = daily[column_names]\n",
    "y = daily['Total']\n",
    "\n",
    "model = LinearRegression(fit_intercept=False)\n",
    "model.fit(X, y)\n",
    "daily['predicted'] = model.predict(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Finally, we can compare the total and predicted bicycle traffic visually:\n",
    "\n",
    "最终我们将预测的自行车交通流量和实际总量进行比较绘制图表："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "daily[['Total', 'predicted']].plot(alpha=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> It is evident that we have missed some key features, especially during the summer time.\n",
    "Either our features are not complete (i.e., people decide whether to ride to work based on more than just these) or there are some nonlinear relationships that we have failed to take into account (e.g., perhaps people ride less at both high and low temperatures).\n",
    "Nevertheless, our rough approximation is enough to give us some insights, and we can take a look at the coefficients of the linear model to estimate how much each feature contributes to the daily bicycle count:\n",
    "\n",
    "很明显我们遗失了一些关键的特征，特别是在夏天的时候。或者我们的特征不完整（如决定人们是否骑行的因素不止上述那些特征）或者数据之间具有非线性的关系我们并未考虑进来（如人们在高温和低温的情况下都会减少骑行）。无论如何，我们这个粗糙的估计给了我们一些内在解释，我们可以查看这个线性模型的系数，从中得到每个特征是如何影响每天自行车总量的："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Mon             1031.250152\n",
       "Tue             1138.417420\n",
       "Wed             1241.952231\n",
       "Thu             1033.464822\n",
       "Fri              430.231290\n",
       "Sat            -1949.104025\n",
       "Sun            -1925.447365\n",
       "holiday        -2214.497205\n",
       "daylight_hrs     240.062223\n",
       "PRCP           -1389.481290\n",
       "dry day         1031.715058\n",
       "Temp (C)         135.081658\n",
       "annual            37.916145\n",
       "dtype: float64"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params = pd.Series(model.coef_, index=X.columns)\n",
    "params"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> These numbers are difficult to interpret without some measure of their uncertainty.\n",
    "We can compute these uncertainties quickly using bootstrap resamplings of the data:\n",
    "\n",
    "这些数字如果没有一种对它们不确定性的度量方式的话很难解读。我们可以使用启动对数据的重采样来快速的计算这些不确定性："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.utils import resample\n",
    "np.random.seed(1)\n",
    "err = np.std([model.fit(*resample(X, y)).coef_\n",
    "              for i in range(1000)], 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> With these errors estimated, let's again look at the results:\n",
    "\n",
    "估计误差后，我们看一下结果："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              effect  error\n",
      "Mon           1031.0  283.0\n",
      "Tue           1138.0  266.0\n",
      "Wed           1242.0  269.0\n",
      "Thu           1033.0  276.0\n",
      "Fri            430.0  261.0\n",
      "Sat          -1949.0  260.0\n",
      "Sun          -1925.0  275.0\n",
      "holiday      -2214.0  478.0\n",
      "daylight_hrs   240.0   31.0\n",
      "PRCP         -1389.0  175.0\n",
      "dry day       1032.0  103.0\n",
      "Temp (C)       135.0   10.0\n",
      "annual          38.0  109.0\n"
     ]
    }
   ],
   "source": [
    "print(pd.DataFrame({'effect': params.round(0),\n",
    "                    'error': err.round(0)}))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> We first see that there is a relatively stable trend in the weekly baseline: there are many more riders on weekdays than on weekends and holidays.\n",
    "We see that for each additional hour of daylight, 129 ± 9 more people choose to ride; a temperature increase of one degree Celsius encourages 65 ± 4 people to grab their bicycle; a dry day means an average of 548 ± 33 more riders, and each inch of precipitation means 665 ± 62 more people leave their bike at home.\n",
    "Once all these effects are accounted for, we see a modest increase of 27 ± 18 new daily riders each year.\n",
    "\n",
    "首先看到的是每周相对稳定的变化趋势：显然工作日比周末的骑行者要多得多。我们每天日照时间多一个小时，我们就会多出240.0 ± 31.0个骑行者；气温升高一摄氏度会多出135.0 ± 10.0个骑行者；晴天意味着会多出1032.0 ± 103.0个骑行者；而每多一英寸降雨意味着会有1389.0 ± 175.0个人决定将自行车留在家。一旦所有因素都计算在内，我们发现每年同一天会平均多出38.0 ± 109.0个骑行者。\n",
    "\n",
    "译者注：上述数据根据译者的计算结果进行了修改。\n",
    "\n",
    "> Our model is almost certainly missing some relevant information. For example, nonlinear effects (such as effects of precipitation *and* cold temperature) and nonlinear trends within each variable (such as disinclination to ride at very cold and very hot temperatures) cannot be accounted for in this model.\n",
    "Additionally, we have thrown away some of the finer-grained information (such as the difference between a rainy morning and a rainy afternoon), and we have ignored correlations between days (such as the possible effect of a rainy Tuesday on Wednesday's numbers, or the effect of an unexpected sunny day after a streak of rainy days).\n",
    "These are all potentially interesting effects, and you now have the tools to begin exploring them if you wish!\n",
    "\n",
    "我们的模型基本可以肯定遗漏了一些相关的信息。例如，非线性效果（比方说降水量*和*低气温的共同作用）和每个变量的非线性趋势（比方说在非常热和非常冷的天气下骑车的缩减量），这个模型都没有计算在内。除此之外，我们还抛弃了一些细颗粒度的信息（例如下雨早晨和下雨下午的区别），而且我们还忽略了连续天数之间的关联（比方说预报周三下雨结果周二就下雨了或者是连续雨天后的一个意料外的晴天）。这些都是潜在有趣的效应，并且你现在已经有了能够进一步探索它们的工具了。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!--NAVIGATION-->\n",
    "< [In Depth: Naive Bayes Classification](05.05-Naive-Bayes.ipynb) | [Contents](Index.ipynb) | [In-Depth: Support Vector Machines](05.07-Support-Vector-Machines.ipynb) >\n",
    "\n",
    "<a href=\"https://colab.research.google.com/github/jakevdp/PythonDataScienceHandbook/blob/master/notebooks/05.06-Linear-Regression.ipynb\"><img align=\"left\" src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open in Colab\" title=\"Open and Execute in Google Colaboratory\"></a>\n"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
